Carte à puces – Bac informatique théorique 2019 [ Bac scientifique ]

Algo et Python 17-10-24

58 0

Sujet bac informatique théorique 2019 (Bac scientifique)

Une société commerciale cherche à automatiser l'accès à ces services via des cartes à puces. Chaque carte est caractérisée par un identifiant unique, une date de création et un code d'accès. Pour cela, on propose d'écrire un programme Python permettant de :

1) Stocker les identifiants de N cartes dans un tableau IDENT (avec 3<= N <= 50), sachant que l'identifiant est une chaîne formée de 8 chiffres. 2) Stocker les dates de création de ces N cartes d'accès dans un tableau DATE, sachant qu'une date de création est une chaîne formée de deux parties : le jour J et le mois M séparés par le caractère "/" (On ne tiendra compte que des contrôles: J est un entier compris entre 1 et 31 et M est un entier compris entre 1 et 12) 3) Déterminer dans un tableau CODE les N codes à partir du tableau DATE en utilisant le principe ci-après, sachant qu'un code est une chaîne de 4 chiffres : - Concaténer J et M pour former un nombre de 2, 3 ou 4 chiffres. - Multiplier ce nombre par un entier aléatoire X compris entre 5 et 64 afin d'obtenir un nouveau nombre Y - Former le code de quatre chiffres comme suit : Si Y est un entier de 4 chiffres, déplacer le chiffre des milliers vers la droite de ce nombre. Si Y < 1000, ajouter des zéros (0) à droite de ce nombre pour que sa longueur soit égale à 4 Si Y > 9999, additionner le nombre formé de 4 chiffres de gauche au nombre formé des chiffres restants à droite jusqu'à ce que sa longueur soit égale à 4.

4) Afficher les informations relatives à chacune des cartes sous la forme suivante :

Identifiant de la carte : Date de sa création : Code

Exemple : Pour N=3 et les deux tableaux suivants :

IDENT:

12345678

23456789

tableau 34567891

DATE:

8/11

2/1

24/12

On obtient le tableau CODE suivant:

CODE:

1108

6720

1314

En effet, les codes des cartes sont obtenus comme suit :

- Pour la carte N°1, la concaténation de J et M donne le nombre 811. En supposant que l'entier aléatoire X=10, le nombre obtenu est égal à 8110 (811*10) qui est composé de 4 chiffres. en déplaçant le chiffres des milliers (8) vers la droite, on obtient le code 1108.

- Pour la carte N°2, la concaténation de J et M donne le nombre 21. En supposant que l'entier aléatoire X=32 , le nombre obtenu est égal à 672(21*32) qui est < 1000. En ajoutant un zéro à droite pour que sa longueur soit égale à 4, on obtient le code 6720. - Pour la carte N°3, la concaténation de J et M donne le nombre 2412. En supposant que l'entier aléatoire X=53 , le nombre obtenu est égal à 127836(2412*53) qui est > 9999. Le nombre formé des 4 chiffres de gauche (1278) sera additionné au nombre formé des chiffres restants à droite (36), on obtient le code 1314 (1278+36).

Le programme affiche :

12345678 : 8/11 : 1108

23456789 : 2/1 : 6720

34567891 : 24/12 : 1314

Solution Algorithmique

Dans cet algorithme, On va utiliser 5 fonctions et 2 procédures:

Algorithme du programme Principal

Algorithme codes_cartes_puces
Debut
     n<-saisie_taille()
     remplir(ident,date,n)
     inserer_afficher_codes(ident,date,code,n)
Fin

Algorithme codes_cartes_puces

Debut

n<-saisie_taille()

remplir(ident,date,n)

inserer_afficher_codes(ident,date,code,n)

Fin

Déclaration des objets

Objet	Type / Nature
ident	tableau des chaînes des caractères
date	tableau des chaînes des caractères
code	tableau des chaînes des caractères
n	entier

La fonction saisie_taille

Cette fonction saisit la taille du tableau entre 3 et 50.

fonction saisie_taille():entier
Début
       Ecrire("donner un entier entre 3 et 50 "))
       Lire(n)
       Tant que (n<3) ou (n>50) faire
           Ecrire("donner un entier entre 3 et 50 ")) 
           Lire(n)
       Fin tant que
       retourner n
Fin

fonction saisie_taille():entier

Début

Ecrire("donner un entier entre 3 et 50 "))

Lire(n)

Tant que (n<3) ou (n>50) faire

Ecrire("donner un entier entre 3 et 50 "))

Lire(n)

Fin tant que

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction verif_identifiant

Cette fonction vérifie que la chaîne est formée de 8 chiffres.

fonction verif_identifiant(ch:chaine):booleen
Début
     # verifier que l'identifiant est forme de 8 chiffres
     Si long(ch)=8 alors
       i<-0
       Tant que (i<long(ch)-1) et ('0'<=ch[i]<='9') alors
         i<-i+1
       Fin tant que  
       retourner ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres

     Sinon
       return Faux # l'identifiant n'est pas forme de 8 chiffres 
     Fin si 
Fin

fonction verif_identifiant(ch:chaine):booleen

Début

# verifier que l'identifiant est forme de 8 chiffres

Si long(ch)=8 alors

i<-0

Tant que (i<long(ch)-1) et ('0'<=ch[i]<='9') alors

i<-i+1

Fin tant que

retourner ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres

Sinon

return Faux # l'identifiant n'est pas forme de 8 chiffres

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La fonction generer_code

Cette fonction vérifie que le nouveau identifiant est unique dans le tableau des identifiant.

fonction verif_unicite_identifiant(t:tab;i:entier):booleen
Début
     j<-0
     #verifier que le nouveau identifiant est unique
     Tant que j<i et t[j]!=t[i] faire
        j=j+1
     Fin tant que 
     Si j=i alors
        retourner Vrai # le nouveau identifiant est unique
     Sinon
        retourner Faux # le nouveau identifiant n'est pas unique
     Fin si
Fin

fonction verif_unicite_identifiant(t:tab;i:entier):booleen

Début

j<-0

#verifier que le nouveau identifiant est unique

Tant que j<i et t[j]!=t[i] faire

j=j+1

Fin tant que

Si j=i alors

retourner Vrai # le nouveau identifiant est unique

Sinon

retourner Faux # le nouveau identifiant n'est pas unique

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
j	entier

La fonction verif_date

Cette fonction vérifie que la date respecte le format J/M avec J est un entier compris entre 1 et 31 et M est un entier compris entre 1 et 12.

fonction verif_date(ch:chaine):booleen
Début
     Si Pos(ch,'/') >=0 alors
       i<-0
       Tant que (i<Pos(ch,'/')) et ('0'<=ch[i]<='9') alors
          i<-i+1
       Fin tant que
       Si i=Pos(ch,'/') alors
           # verifier si le nombre des jours entre 1 et 31 
           Si (1<=Valeur(Sous_chaine(ch,0,Pos(ch,'/'))<=31) alors 
               i<-i+1
               Tant que i<long(ch) et ('0'<=ch[i]<='9') alors
                 i<-i+1
               Fin tant que
               Si i=long(ch) alors
               # verifier si le nombre des mois entre 1 et 12
                  retourner (1<=Valeur(Sous_chaine(ch,Pos(ch,'/')+1,long(ch)])<=12)
               Sinon
                 retourner Faux
               Fin si
           Sinon
             retourner Faux
           Fin si
       Sinon
         retourner Faux
       Fin si
     Sinon
        retourner Faux
     Fin si
Fin

fonction verif_date(ch:chaine):booleen

Début

Si Pos(ch,'/') >=0 alors

i<-0

Tant que (i<Pos(ch,'/')) et ('0'<=ch[i]<='9') alors

i<-i+1

Fin tant que

Si i=Pos(ch,'/') alors

# verifier si le nombre des jours entre 1 et 31

Si (1<=Valeur(Sous_chaine(ch,0,Pos(ch,'/'))<=31) alors

i<-i+1

Tant que i<long(ch) et ('0'<=ch[i]<='9') alors

i<-i+1

Fin tant que

Si i=long(ch) alors

# verifier si le nombre des mois entre 1 et 12

retourner (1<=Valeur(Sous_chaine(ch,Pos(ch,'/')+1,long(ch)])<=12)

Sinon

retourner Faux

Fin si

Sinon

retourner Faux

Fin si

Sinon

retourner Faux

Fin si

Sinon

retourner Faux

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure remplir

Cette procédure remplit les deux tableaux IDENT et DATE respectivement par : les identificateurs et les dates de création des carte à puces.

procedure remplir(@ident:tab,@date:tab;n:entier)
Début  
    
    # saisir le 1er identifiant dans le tableau ident
    Ecrire("donner un identifiant N°0 forme de chiffres: ")
    Lire(ident[0])
    Tant que (verif_identifiant(ident[0])=Faux) faire
        Ecrire("donner un identifiant N°0 forme de chiffres: ")
        lire(ident[0])
    Fin tant que
    # saisir la 1ere date dans le tableau date
    Ecrire("donner date de creation identifiant N°0 forme jour/mois: ")
    Lire(date[0])
    Tant que verif_date(date[0])=Faux faire
       Ecrire("donner date de creation identifiant N°0 forme jour/mois:") 
       Lire(date[0])
    Fin tant que
  
    # remplir le tableau des identifiants 
    Pour i de 1 à n-1 faire
       Ecrire("donner un identifiant N°"+i+" forme de chiffres: ")
       Lire(ident[i])
       Tant que (verif_identifiant(ident[i])=Faux) ou (verif_unicite_identifiant(ident,i)=Faux) faire
           Ecrire("donner un identifiant N°"+i+" forme de chiffres: ")
           Lire(ident[i])
       Fin tant que
       # remplir le tableau des dates de creation des cartes 
       Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois: ")
       Lire(date[i])
       Tant que (verif_date(date[i])=Faux) faire
           Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois:")
           date[i]
       Fin tant que
     Fin pour
Fin

procedure remplir(@ident:tab,@date:tab;n:entier)

Début

# saisir le 1er identifiant dans le tableau ident

Ecrire("donner un identifiant N°0 forme de chiffres: ")

Lire(ident[0])

Tant que (verif_identifiant(ident[0])=Faux) faire

Ecrire("donner un identifiant N°0 forme de chiffres: ")

lire(ident[0])

Fin tant que

# saisir la 1ere date dans le tableau date

Ecrire("donner date de creation identifiant N°0 forme jour/mois: ")

Lire(date[0])

Tant que verif_date(date[0])=Faux faire

Ecrire("donner date de creation identifiant N°0 forme jour/mois:")

Lire(date[0])

Fin tant que

# remplir le tableau des identifiants

Pour i de 1 à n-1 faire

Ecrire("donner un identifiant N°"+i+" forme de chiffres: ")

Lire(ident[i])

Tant que (verif_identifiant(ident[i])=Faux) ou (verif_unicite_identifiant(ident,i)=Faux) faire

Ecrire("donner un identifiant N°"+i+" forme de chiffres: ")

Lire(ident[i])

Fin tant que

# remplir le tableau des dates de creation des cartes

Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois: ")

Lire(date[i])

Tant que (verif_date(date[i])=Faux) faire

Ecrire("donner date de creation identifiant N°"+i+" forme jour/mois:")

date[i]

Fin tant que

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La fonction generer_code

Cette fonction transforme la date de la création de la carte à puce pour obtenir un code.

Fonction generer_code(ch:chaine):chaine
Début  
    #concatiner j et m
    ch<-Sous_chaine(ch,0,Pos(ch,'/'))+Sous_chaine(ch, Pos(ch,'/')+1,long(ch))
    x<-Alea(5, 64)
    ch<-Conch(Valeur(ch)*x)

    Si long(ch)=4 alors # Si le code est forme de 4 chiffres
       # deplacer le chiffredes milliers vers la droite du nombre
       retourner Sous_chaine(ch,1,long(ch))+ch[0]
    Sinon si long(ch)=3 alors# Si le code est forme de 3 chiffres
       retourner ch+'0' # ajouter 0 à la droite du nombre
    Sinon si long(ch)=2 alors # Si le code est forme de 2 chiffres
       retourner ch+'00' # ajouter 00 à la droite du nombre
    Sinon si long(ch)>4 alors #Si le code est forme de plus de 4 chiffres
       #additionner le nombre forme de 4 chiffres de gauche
       #au nombre forme des chiffre jusq'à sa longeur = 4
       s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch))
         Tant que (s>10000) alors
           ch<-Convch(s)
           s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch)) 
         Fin tant que 
         retourner str(s)
    Fin si    
Fin

Fonction generer_code(ch:chaine):chaine

Début

#concatiner j et m

ch<-Sous_chaine(ch,0,Pos(ch,'/'))+Sous_chaine(ch, Pos(ch,'/')+1,long(ch))

x<-Alea(5, 64)

ch<-Conch(Valeur(ch)*x)

Si long(ch)=4 alors # Si le code est forme de 4 chiffres

# deplacer le chiffredes milliers vers la droite du nombre

retourner Sous_chaine(ch,1,long(ch))+ch[0]

Sinon si long(ch)=3 alors# Si le code est forme de 3 chiffres

retourner ch+'0' # ajouter 0 à la droite du nombre

Sinon si long(ch)=2 alors # Si le code est forme de 2 chiffres

retourner ch+'00' # ajouter 00 à la droite du nombre

Sinon si long(ch)>4 alors #Si le code est forme de plus de 4 chiffres

#additionner le nombre forme de 4 chiffres de gauche

#au nombre forme des chiffre jusq'à sa longeur = 4

s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch))

Tant que (s>10000) alors

ch<-Convch(s)

s<-Valeur(Sous_chaine(ch,0,4))+Valeur(Sous_chaine(ch,4,long(ch))

Fin tant que

retourner str(s)

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
s	entier

La procédure inserer_afficher_codes

Cette procédure insère les codes dans le tableau code et affiche les données de chaque carte à puce.

procedure inserer_afficher_codes(ident:tab,date:tab,@code:tab,n:entier)
Début  
      Pour i de 0 à n-1 faire
         code[i]<-generer_code(date[i])
         Ecrire(ident[i]+' : ' +date[i]+' : '+code[i])
      Fin pour 
Fin

procedure inserer_afficher_codes(ident:tab,date:tab,@code:tab,n:entier)

Début

Pour i de 0 à n-1 faire

code[i]<-generer_code(date[i])

Ecrire(ident[i]+' : ' +date[i]+' : '+code[i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

Solution en Python

from numpy import array
from random import *
# declaration du tableau des identifiants des cartes à puces 
ident=array([str]*60) 
# declaration du tableau des dates de creation des cartes à puces 
date=array([str]*60)
# declaration du tableau des codes 
code=array([str]*60)


def saisie_taille():
    n=int(input("donner un entier entre 3 et 50: "))
    while (n<3) or (n>50):
       n=int(input("donner un entier entre 3 et 50: "))
    return n

def verif_identifiant(ch):
    # verifier que l'identifiant est forme de 8 chiffres
    if len(ch)==8 :
      i=0
      while (i<len(ch)-1) and ('0'<=ch[i]<='9'):
         i=i+1
         
      return ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres

    else:
        return False # l'identifiant n'est pas forme de 8 chiffres
    
def verif_unicite_identifiant(t,i):
    j=0
    #verifier que le nouveau identifiant est unique
    while j<i and t[j]!=t[i]:
       j=j+1
       
    
    if j==i :
        return True  # le nouveau identifiant est unique
    else:
        return False # le nouveau identifiant n'est pas unique
    
def verif_date(ch):
    if ch.find('/') >=0 :
        i=0
        while (i<ch.find('/')) and ('0'<=ch[i]<='9'):
            i=i+1
        if i==ch.find('/') :
           # verifier si le nombre des jours entre 1 et 31 
           if (1<=int(ch[0:ch.find('/')])<=31): 
               i=i+1
               while i<len(ch) and ('0'<=ch[i]<='9'):
                   i=i+1
               if i==len(ch):
                   # verifier si le nombre des mois entre 1 et 12
                   return (1<=int(ch[ch.find('/')+1:len(ch)])<=12)
               else:
                   return False
           else:
               return False
        else:
            return False
    else:
        return False
       
   
    
def remplir(ident,date,n):
   # remplir le tableau des identifiants
   ident[0]=input("donner un identifiant N°0 forme de chiffres: ")
   while (verif_identifiant(ident[0])==False):
        ident[0]=input("donner un identifiant N°0 forme de chiffres: ")
   
   # remplir le tableau des dates de creation des cartes      
   date[0]=input("donner date de creation identifiant N°0 forme jour/mois: ")
   while verif_date(date[0])==False:
        date[0]=input("donner date de creation identifiant N°0 forme jour/mois:")     
   
   # remplir le tableau des identifiants    
   for i in range (1,n) :
     ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ")
     while (verif_identifiant(ident[i])==False) or  (verif_unicite_identifiant(ident,i)==False):
        ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ")
     
     # remplir le tableau des dates de creation des cartes      
     date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois: ")
     while (verif_date(date[i])==False):
        date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois:")
     
        
def generer_code(ch):
    #concatiner j et m
    ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)]
    x=randint(5, 64)
    ch=str(int(ch)*x)
  
    if len(ch)==4 :# Si le code est forme de 4 chiffres
        # deplacer le chiffredes milliers vers la droite du nombre
        return ch[1:len(ch)]+ch[0]
    elif len(ch)==3:# Si le code est forme de 3 chiffres
        return ch+'0' # ajouter 0 à la droite du nombre
    elif len(ch)==2: # Si le code est forme de 2 chiffres
        return ch+'00' # ajouter 00 à la droite du nombre
    elif len(ch)>4:#Si le code est forme de plus de 4 chiffres
        #additionner le nombre forme de 4 chiffres de gauche
        #au nombre forme des chiffre jusq'à sa longeur = 4
        s=int(ch[0:4])+int(ch[4:len(ch)])
        while (s>10000):
            ch=str(s)
            s=int(ch[0:4])+int(ch[4:len(ch)])            
        return str(s)
    

def inserer_afficher_codes(ident,date,code,n):
  for i in range (n):
     code[i]=generer_code(date[i])
     print(ident[i]+' : ' +date[i]+' : '+code[i])       


#programme principal
n=saisie_taille()
remplir(ident,date,n)
inserer_afficher_codes(ident,date,code,n)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

from numpy import array

from random import *

# declaration du tableau des identifiants des cartes à puces

ident=array([str]*60)

# declaration du tableau des dates de creation des cartes à puces

date=array([str]*60)

# declaration du tableau des codes

code=array([str]*60)

def saisie_taille():

n=int(input("donner un entier entre 3 et 50: "))

while (n<3) or (n>50):

n=int(input("donner un entier entre 3 et 50: "))

return n

def verif_identifiant(ch):

# verifier que l'identifiant est forme de 8 chiffres

if len(ch)==8 :

i=0

while (i<len(ch)-1) and ('0'<=ch[i]<='9'):

i=i+1

return ('0'<=ch[i]<='9') # l'identifiant est forme de 8 chiffres

else:

return False # l'identifiant n'est pas forme de 8 chiffres

def verif_unicite_identifiant(t,i):

j=0

#verifier que le nouveau identifiant est unique

while j<i and t[j]!=t[i]:

j=j+1

if j==i :

return True # le nouveau identifiant est unique

else:

return False # le nouveau identifiant n'est pas unique

def verif_date(ch):

if ch.find('/') >=0 :

i=0

while (i<ch.find('/')) and ('0'<=ch[i]<='9'):

i=i+1

if i==ch.find('/') :

# verifier si le nombre des jours entre 1 et 31

if (1<=int(ch[0:ch.find('/')])<=31):

i=i+1

while i<len(ch) and ('0'<=ch[i]<='9'):

i=i+1

if i==len(ch):

# verifier si le nombre des mois entre 1 et 12

return (1<=int(ch[ch.find('/')+1:len(ch)])<=12)

else:

return False

else:

return False

else:

return False

else:

return False

def remplir(ident,date,n):

# remplir le tableau des identifiants

ident[0]=input("donner un identifiant N°0 forme de chiffres: ")

while (verif_identifiant(ident[0])==False):

ident[0]=input("donner un identifiant N°0 forme de chiffres: ")

# remplir le tableau des dates de creation des cartes

date[0]=input("donner date de creation identifiant N°0 forme jour/mois: ")

while verif_date(date[0])==False:

date[0]=input("donner date de creation identifiant N°0 forme jour/mois:")

# remplir le tableau des identifiants

for i in range (1,n) :

ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ")

while (verif_identifiant(ident[i])==False) or (verif_unicite_identifiant(ident,i)==False):

ident[i]=input("donner un identifiant N°"+str(i)+" forme de chiffres: ")

# remplir le tableau des dates de creation des cartes

date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois: ")

while (verif_date(date[i])==False):

date[i]=input("donner date de creation identifiant N°"+str(i)+" forme jour/mois:")

def generer_code(ch):

#concatiner j et m

ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)]

x=randint(5, 64)

ch=str(int(ch)*x)

if len(ch)==4 :# Si le code est forme de 4 chiffres

# deplacer le chiffredes milliers vers la droite du nombre

return ch[1:len(ch)]+ch[0]

elif len(ch)==3:# Si le code est forme de 3 chiffres

return ch+'0' # ajouter 0 à la droite du nombre

elif len(ch)==2: # Si le code est forme de 2 chiffres

return ch+'00' # ajouter 00 à la droite du nombre

elif len(ch)>4:#Si le code est forme de plus de 4 chiffres

#additionner le nombre forme de 4 chiffres de gauche

#au nombre forme des chiffre jusq'à sa longeur = 4

s=int(ch[0:4])+int(ch[4:len(ch)])

while (s>10000):

ch=str(s)

s=int(ch[0:4])+int(ch[4:len(ch)])

return str(s)

def inserer_afficher_codes(ident,date,code,n):

for i in range (n):

code[i]=generer_code(date[i])

print(ident[i]+' : ' +date[i]+' : '+code[i])

#programme principal

n=saisie_taille()

remplir(ident,date,n)

inserer_afficher_codes(ident,date,code,n)

Exécution du programme:

Solution en Python et Designer QT

Pour créer une application en Python et Designer QT qui stocke les données des cartes à puces, on va suivre ces étapes:

1- Créer l'interface graphique avec Qt Designer

a- Ouvrez Qt Designer et créez un nouveau fichier de type Main Window.

b- Ajoutez ces widgets:

QLineEdit nommé 'ch1' pour entrer les identificateurs des cartes à puces

QLineEdit nommé 'ch2' pour entrer les dates de création des cartes à puces

QPushButton nommé 'remplirid_bt' pour mettre les identificateurs des cartes à puces dans le tableau IDENT.

QPushButton nommé 'remplirdate_bt' pour mettre les dates dans le tableau DATE.

QPushButton nommé 'afficher_bt' pour afficher la liste des identificateurs des cartes à puces ainsi que leurs dates de création et leurs codes générés.

QLabel nommé 'tabident_label' pour contenir les identificateurs des cartes à puces.

QLabel nommé 'tabdate_label' pour contenir les dates de création des cartes à puces.

QLabel nommé 'tabcode_label' pour contenir les codes des cartes à puces.

QLabel nommé 'msg' pour afficher des messages d'erreur.

QLabel nommé 'resultat' pour contenir la liste des nouveau-nés ayant une heure de naissance miroir et les nombres des nouveau-nés pour chaque type d'heure miroir.

Enregistrez le fichier avec l'extension .ui, par exemple tabtab-3.ui.

2- Créer le script Python pour l'application

Voici un exemple de script Python qui utilise l'interface graphique générée par Qt Designer.

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


from numpy import array
from random import *
# declaration du tableau des identifiants des cartes à puces 
ident=array([str]*60) 
# declaration du tableau des dates de creation des cartes à puces 
date=array([str]*60)
# declaration du tableau des codes 
code=array([str]*60)


app = QApplication([])
windows = loadUi ("tabtab-3.ui")

# Fonction qui supprime des espaces de la chaine des carcatères
def supprimer_espaces (ch) :
    while(ch[0]==' '): # elimnier tous les espaces au début de la chaine
     ch=ch[1:len(ch)]
         
    while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine
     ch=ch[0:len(ch)-1]       
        
    while (ch.find('  ')>0): 
     ch=ch.replace("  ", " ") # remplacer les doubles espaces apar un seul espace
     
    return ch

def verif_unicite_identifiant(t,i):
    j=0
    #verifier que le nouveau identifiant est unique
    while j<i and t[j]!=t[i]:
       j=j+1
       
    
    if j==i :
        return True  # le nouveau identifiant est unique
    else:
        return False # le nouveau identifiant n'est pas unique
    
def verif_unicite_identifiant(t,i):
    j=0
    #verifier que le nouveau identifiant est unique
    while j<i and t[j]!=t[i]:
       j=j+1
       
    
    if j==i :
        return True  # le nouveau identifiant est unique
    else:
        return False # le nouveau identifiant n'est pas unique    

# Procedure qui remplit le tableau IDENT des identificateurs  
def createTabIDENT():
    windows.tabident_label.clear()
    windows.msg.clear() 
    global n #pour la taile du tableau a des utilisateurs
    ch = windows.ch1.text()
   
    if ch=="":
            windows.msg.setText("Veuillez remplir la chaîne")
    else:      
      windows.msg.clear() # effacer le message d erreur
      ch= supprimer_espaces(ch)
      i=0
      j=0        
      ch1=''
        
      unicite_identifiant=True # pour verifier l'unicite des identificateurs
      test_8chiffres=True
      # parcourir les caracteres de la chaine CH1
      while(i<len(ch)) and (test_8chiffres) and(unicite_identifiant) and (('0'<=ch[i].upper()<='9')or (ch[i]==' ')):
        if  (ch[i]!=' ') :
            ch1=ch1+ch[i]
        if ((ch[i]==' ') or (i==len(ch)-1)) :
            # remplir le tableau IDENT par des identificateurs
            ident[j]=ch1
            
            if j>=1:
                unicite_identifiant=verif_unicite_identifiant(ident,j)
            
            test_8chiffres=(len(ch1)==8)
            
            ch1=''
            j=j+1
        
        i=i+1
        
      if (i==len(ch)) and (test_8chiffres) and (unicite_identifiant)  :
        if 3<=j<=50:            
             n=j
             tab=''
             for k in range (j) :
                tab=tab+ 'ident['+str(k)+']= '+ident[k]+ '\n'
          
             #afficher les elements du tableau  
             windows.tabident_label.setText(tab)  
        else:    
             windows.msg.setText("la taille du tableau a doit etre entre 3 et 50")
      else:    
             windows.msg.setText("les identifiants doivent differentes et formes de 8 chiffres")


def verif_heure(ch):
  # verifier la longueur de la chaine  
  if len(ch)==5:  
    # verifier la chaine est compse des chiffres et le symbole :
    if ('0'<=ch[0]<='2') and ('0'<=ch[1]<='9') and (ch[2]==':') and ('0'<=ch[3]<='5') and ('0'<=ch[4]<='9'):
        # verifier la valeur de HH est comprise entre 0 et 23
        ## verifier la valeur de MM est comprise entre 0 et 59
        if (0<=int(ch[0]+ch[1])<=23) and (0<=int(ch[3]+ch[4])<=59):
            return True
        else:
            return False
    else:
        return False
  else: 
    return False


def verif_date(ch):
    if ch.find('/') >=0 :
        i=0
        while (i<ch.find('/')) and ('0'<=ch[i]<='9'):
            i=i+1
        if i==ch.find('/') :
           # verifier si le nombre des jours entre 1 et 31 
           if (1<=int(ch[0:ch.find('/')])<=31): 
               i=i+1
               while i<len(ch) and ('0'<=ch[i]<='9'):
                   i=i+1
               if i==len(ch):
                   # verifier si le nombre des mois entre 1 et 12
                   return (1<=int(ch[ch.find('/')+1:len(ch)])<=12)
               else:
                   return False
           else:
               return False
        else:
            return False
    else:
        return False

# Procedure qui remplit un tableau des dates de creation des cartes a puce 
def createTabDATE():
    windows.tabdate_label.clear()
    windows.msg.clear() 
    ch = windows.ch2.text()
    
   
    if ch=="":
            windows.msg.setText("Veuillez remplir la chaîne")
    else:      
      windows.msg.clear() # effacer le message d erreur
      ch= supprimer_espaces(ch)
      i=0
      j=0        
      ch1=''
      verifdate=True
        # parcourir les caracteres de la chaine CH2
      while(i<len(ch)) and (verifdate) and (('0'<=ch[i]<='9')or (ch[i]==' ' )or (ch[i]=='/')):
            if  ('0'<=ch[i]<='9')or (ch[i]=='/'):
               ch1=ch1+ch[i]
            if ((ch[i]==' ') or (i==len(ch)-1)) :
                # remplir le tableau date par des dates de creation des cartes a puce
                date[j]=ch1
                # verifier le format de la date Jour/Mois
                verifdate=verif_date(ch1)  
                ch1=''
                j=j+1
            i=i+1
            

      if (i==len(ch)) and (verifdate) :    
        if j==n: #la taille du tableau r doit etre egal a la taille du tableau IDENT             
             tab=''
             for k in range (j) :
                tab=tab+ 'date['+str(k)+']= '+date[k]+ '\n'
          
             #afficher les elements du tableau  
             windows.tabdate_label.setText(tab)  
        else:    
             windows.msg.setText("la taille du tableau DATE doit etre egal a "+str(n))
      else:    
             windows.msg.setText("Les dates doivent etre sous forme jour/mois ")



def generer_code(ch):
    #concatiner j et m
    ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)]
    x=randint(5, 64)
    ch=str(int(ch)*x)
  
    if len(ch)==4 :# Si le code est forme de 4 chiffres
        # deplacer le chiffredes milliers vers la droite du nombre
        return ch[1:len(ch)]+ch[0]
    elif len(ch)==3:# Si le code est forme de 3 chiffres
        return ch+'0' # ajouter 0 à la droite du nombre
    elif len(ch)==2: # Si le code est forme de 2 chiffres
        return ch+'00' # ajouter 00 à la droite du nombre
    elif len(ch)>4:#Si le code est forme de plus de 4 chiffres
        #additionner le nombre forme de 4 chiffres de gauche
        #au nombre forme des chiffre jusq'à sa longeur = 4
        s=int(ch[0:4])+int(ch[4:len(ch)])
        while (s>10000):
            ch=str(s)
            s=int(ch[0:4])+int(ch[4:len(ch)])            
        return str(s)
    

def inserer_afficher_codes():
  resultat=''
  tab=''
  for i in range (n):
     code[i]=generer_code(date[i])
     tab=tab+ 'code['+str(i)+']= '+code[i]+ '\n'
     resultat=resultat+ident[i]+' : ' +date[i]+' : '+code[i]+'\n'
          
  #afficher les elements du tableau Code  
  windows.tabcode_label.setText(tab)  
  windows.resultat.setText(resultat)
     
     
windows.remplirid_bt.clicked.connect ( createTabIDENT )
windows.remplirdate_bt.clicked.connect ( createTabDATE )
windows.afficher_bt.clicked.connect ( inserer_afficher_codes )

windows.show()
app.exec_()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

from PyQt5.uic import loadUi

from PyQt5.QtWidgets import QApplication

from numpy import array

from random import *

# declaration du tableau des identifiants des cartes à puces

ident=array([str]*60)

# declaration du tableau des dates de creation des cartes à puces

date=array([str]*60)

# declaration du tableau des codes

code=array([str]*60)

app = QApplication([])

windows = loadUi ("tabtab-3.ui")

# Fonction qui supprime des espaces de la chaine des carcatères

def supprimer_espaces (ch) :

while(ch[0]==' '): # elimnier tous les espaces au début de la chaine

ch=ch[1:len(ch)]

while(ch[len(ch)-1]==' '): # elimnier tous les espaces a la fin de la chaine

ch=ch[0:len(ch)-1]

while (ch.find(' ')>0):

ch=ch.replace(" ", " ") # remplacer les doubles espaces apar un seul espace

return ch

def verif_unicite_identifiant(t,i):

j=0

#verifier que le nouveau identifiant est unique

while j<i and t[j]!=t[i]:

j=j+1

if j==i :

return True # le nouveau identifiant est unique

else:

return False # le nouveau identifiant n'est pas unique

def verif_unicite_identifiant(t,i):

j=0

#verifier que le nouveau identifiant est unique

while j<i and t[j]!=t[i]:

j=j+1

if j==i :

return True # le nouveau identifiant est unique

else:

return False # le nouveau identifiant n'est pas unique

# Procedure qui remplit le tableau IDENT des identificateurs

def createTabIDENT():

windows.tabident_label.clear()

windows.msg.clear()

global n #pour la taile du tableau a des utilisateurs

ch = windows.ch1.text()

if ch=="":

windows.msg.setText("Veuillez remplir la chaîne")

else:

windows.msg.clear() # effacer le message d erreur

ch= supprimer_espaces(ch)

i=0

j=0

ch1=''

unicite_identifiant=True # pour verifier l'unicite des identificateurs

test_8chiffres=True

# parcourir les caracteres de la chaine CH1

while(i<len(ch)) and (test_8chiffres) and(unicite_identifiant) and (('0'<=ch[i].upper()<='9')or (ch[i]==' ')):

if (ch[i]!=' ') :

ch1=ch1+ch[i]

if ((ch[i]==' ') or (i==len(ch)-1)) :

# remplir le tableau IDENT par des identificateurs

ident[j]=ch1

if j>=1:

unicite_identifiant=verif_unicite_identifiant(ident,j)

test_8chiffres=(len(ch1)==8)

ch1=''

j=j+1

i=i+1

if (i==len(ch)) and (test_8chiffres) and (unicite_identifiant) :

if 3<=j<=50:

n=j

tab=''

for k in range (j) :

tab=tab+ 'ident['+str(k)+']= '+ident[k]+ '\n'

#afficher les elements du tableau

windows.tabident_label.setText(tab)

else:

windows.msg.setText("la taille du tableau a doit etre entre 3 et 50")

else:

windows.msg.setText("les identifiants doivent differentes et formes de 8 chiffres")

def verif_heure(ch):

# verifier la longueur de la chaine

if len(ch)==5:

# verifier la chaine est compse des chiffres et le symbole :

if ('0'<=ch[0]<='2') and ('0'<=ch[1]<='9') and (ch[2]==':') and ('0'<=ch[3]<='5') and ('0'<=ch[4]<='9'):

# verifier la valeur de HH est comprise entre 0 et 23

## verifier la valeur de MM est comprise entre 0 et 59

if (0<=int(ch[0]+ch[1])<=23) and (0<=int(ch[3]+ch[4])<=59):

return True

else:

return False

else:

return False

else:

return False

def verif_date(ch):

if ch.find('/') >=0 :

i=0

while (i<ch.find('/')) and ('0'<=ch[i]<='9'):

i=i+1

if i==ch.find('/') :

# verifier si le nombre des jours entre 1 et 31

if (1<=int(ch[0:ch.find('/')])<=31):

i=i+1

while i<len(ch) and ('0'<=ch[i]<='9'):

i=i+1

if i==len(ch):

# verifier si le nombre des mois entre 1 et 12

return (1<=int(ch[ch.find('/')+1:len(ch)])<=12)

else:

return False

else:

return False

else:

return False

else:

return False

# Procedure qui remplit un tableau des dates de creation des cartes a puce

def createTabDATE():

windows.tabdate_label.clear()

windows.msg.clear()

ch = windows.ch2.text()

if ch=="":

windows.msg.setText("Veuillez remplir la chaîne")

else:

windows.msg.clear() # effacer le message d erreur

ch= supprimer_espaces(ch)

i=0

j=0

ch1=''

verifdate=True

# parcourir les caracteres de la chaine CH2

while(i<len(ch)) and (verifdate) and (('0'<=ch[i]<='9')or (ch[i]==' ' )or (ch[i]=='/')):

if ('0'<=ch[i]<='9')or (ch[i]=='/'):

ch1=ch1+ch[i]

if ((ch[i]==' ') or (i==len(ch)-1)) :

# remplir le tableau date par des dates de creation des cartes a puce

date[j]=ch1

# verifier le format de la date Jour/Mois

verifdate=verif_date(ch1)

ch1=''

j=j+1

i=i+1

if (i==len(ch)) and (verifdate) :

if j==n: #la taille du tableau r doit etre egal a la taille du tableau IDENT

tab=''

for k in range (j) :

tab=tab+ 'date['+str(k)+']= '+date[k]+ '\n'

#afficher les elements du tableau

windows.tabdate_label.setText(tab)

else:

windows.msg.setText("la taille du tableau DATE doit etre egal a "+str(n))

else:

windows.msg.setText("Les dates doivent etre sous forme jour/mois ")

def generer_code(ch):

#concatiner j et m

ch=ch[0:ch.find('/')]+ch[ch.find('/')+1:len(ch)]

x=randint(5, 64)

ch=str(int(ch)*x)

if len(ch)==4 :# Si le code est forme de 4 chiffres

# deplacer le chiffredes milliers vers la droite du nombre

return ch[1:len(ch)]+ch[0]

elif len(ch)==3:# Si le code est forme de 3 chiffres

return ch+'0' # ajouter 0 à la droite du nombre

elif len(ch)==2: # Si le code est forme de 2 chiffres

return ch+'00' # ajouter 00 à la droite du nombre

elif len(ch)>4:#Si le code est forme de plus de 4 chiffres

#additionner le nombre forme de 4 chiffres de gauche

#au nombre forme des chiffre jusq'à sa longeur = 4

s=int(ch[0:4])+int(ch[4:len(ch)])

while (s>10000):

ch=str(s)

s=int(ch[0:4])+int(ch[4:len(ch)])

return str(s)

def inserer_afficher_codes():

resultat=''

tab=''

for i in range (n):

code[i]=generer_code(date[i])

tab=tab+ 'code['+str(i)+']= '+code[i]+ '\n'

resultat=resultat+ident[i]+' : ' +date[i]+' : '+code[i]+'\n'

#afficher les elements du tableau Code

windows.tabcode_label.setText(tab)

windows.resultat.setText(resultat)

windows.remplirid_bt.clicked.connect ( createTabIDENT )

windows.remplirdate_bt.clicked.connect ( createTabDATE )

windows.afficher_bt.clicked.connect ( inserer_afficher_codes )

windows.show()

app.exec_()

Exécution du programme

1) Remplissage du tableau IDENT

2) Remplissage du tableau DATE

3) Remplissage du tableau CODE et affichage des données des cartes à puces

Vous pouvez voir aussi :

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Bras robotique pour Arduino

Arduino UNO 21-11-24

Remplissage automatique des bouteilles en utilisant Arduino et KY-032

Arduino UNO 21-11-24

Robot voiture contrôlé par Micro:bit et télécommande

Micro:bit 20-11-24

Fonctionner un moteur à courant continu de 5V avec Micro:bit

Micro:bit 20-11-24

Construire un GPS commandé par Arduino

Arduino UNO 20-11-24

Atelier robotique

Tutoriels populaires

Allumer une LED connectée à la carte ESP32 via WIFI

ESP32 Wifi 2797vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 2713vues

Allumer une LED par la carte ESP32

ESP32 2553vues

Présentation de la carte ESP32

ESP32 2399vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 2320vues

Construction des robots

Tutoriels plus commentés

Commander trois LEDs par la télécommande en utilisant le capteur KY-032 et la carte Micro:bit

Micro:bit 3 commentaires

Allumer une LED connectée à l’Arduino UNO via WIFI

Arduino UNO Wifi 3 commentaires

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur SSD1306

Arduino UNO 2 commentaires

Système de détection d’obstacles basé sur HC-SR04, afficheur SSD1306 et Arduino UNO

Arduino UNO 2 commentaires

Carte à puces – Bac informatique théorique 2019 [ Bac scientifique ]

Sujet bac informatique théorique 2019 (Bac scientifique)

Solution Algorithmique

Solution en Python

Solution en Python et Designer QT

1- Créer l'interface graphique avec Qt Designer

2- Créer le script Python pour l'application

1) des exercices sur les chaînes des caractères

2) des exercices sur les tableaux

3) des sujets Bac pratique

4) des sujets Bac théorique

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles