|
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 |
procédure Rempli_alea ( @ T:tab; n: entier)
Debut
pour i de 0 à n-1 faire
T[i] ← aléa (a, b)
fin pour
Fin
from numpy import*
from random import randint
def Rempli_alea ( T, n):
for i in range(n) :
t[i]=randint(a, b)
procédure Rempli_trié (@T:tab; n: entier)
Debut
lire (T[0])
pour i de 1 à n-1 faire
Répéter
lire (T[i] )
Jusqu’à T[i] > T[0]
fin pour
Fin
def Rempli_trié ( T, n):
T[0] = int(input(« Saisir T[0]: « ))
for i in range(n) :
T[i] = int(input(« Saisir T[« +str(i)+ »]: « ))
while T[i] < T[i-1]:
T[i] = int(input(« Saisir T[« +str(i)+ »]: »))
procédure Rempli_distinct ( @ T:tab; n: entier)
Debut
lire ( T[0])
pour i de 1 à n-1 faire
Répéter
lire (T[i] )
Jusqu’à Existe(T[i],T,i-1)=Faux
fin pour
Fin
def Rempli_distinct ( T, n):
T[0] = int(input(« Saisir T[0]: « ))
for i in range(1,n) :
T[i] = int(input(« Saisir T[ » + str(i)+ »]: « ))
while Existe(T[i],T,i-1)==False:
T[i] = int(input(« Saisir T[ » + str(i)+ »]: « ))
Tri_par_selection ( @ T:tab; n: entier)
Debut
pour i de 0 à n-1 faire
pour j de i à n-1 faire
si T[j-1]>T[j] alors
Aux ← T[j-1]
T[j-1] ←T[j]
T[j] ← Aux
fin_si
Fin
def Tri_par_Selection ( T, n):
for i in range(0,n):
for j in range(i,n-1) :
if T[j-1]>T[j] :
Aux=T[j-1]
T[j-1]=T[j]
T[j]=Aux
Tri_par_Insertion ( @ T:tab; n: entier)
Debut
pour i de 1 à n-1 faire
k ← T[i]
j ← i-1
tant que( j >= 0) et (k < T[j]) faire
T[j + 1] ← T[j]
j ← j- 1
T[j + 1] ← k
fin tantque
fin pour
Fin
def tri_insertion(T,n):
for i in range(1, n):
k = T[i]
j = i-1
while (j >= 0) and (k < T[j]) :
T[j + 1] = T[j]
j -= 1
T[j + 1] = k
procédure Tri_à_bulles ( @ T:tab; n: entier)
Debut
Répéter
Permute ←faux
Pour i de 1 à n-1 faire
Si ( T[i] > T[i+1]) Alors
Aux ←T[i]
T[i]←T[i+1]
T[i+1]←Aux
Permute ← vrai
FinSi
FinPour
n←n-1
Jusqu’à (Permute = Faux) ou (n=0)
def Tri_à_bulles ( T, n):
for i in range(1, n):
k = T[i]
j = i-1
while j >= 0 and k < T[j] :
T[j + 1] = T[j]
j -= 1
T[j + 1] = k
Fusion_tableaux_triés ( @ F,T,V:tab; n,m: entier)
Debut
i← 0
j← 0
k← 0
tant que (i<(n+m)) et (j<n) et (k<m) faire
si T[j]<V[k] alors
F[i]←T[j]
i←i+1
j←j+1
sinon
F[i]←V[k]
i←i+1
k←k+1
fin_tant que
x←i
si j=n alors
pour i de x à n+m faire
F[i]←V[i-n]
sinon si k=m alors
pour i de x à n+m faire
F[i] ← T[i-m]
fin_si
Fin
def fusion_trié(F,T,V,n,m):
i,j,k=0,0,0
while (i<(n+m))and(j<n) and(k<m):
if T[j]<V[k]:
F[i]=T[j]
i=i+1
j=j+1
else:
F[i]=V[k]
i=i+1
k=k+1
x=i
if j==n:
for i in range(x,n+m):
F[i]=V[i-n]
elif k==m:
for i in range(x,n+m):
F[i]=T[i-m]
return F
procédure insertion_trié ( x: entier; @ T:tab; n: entier)
Debut
i←n
tant que t[i-1]> x faire
t[i] ← t[i-1]
i ← i-1
t[i] ← x
fin_tant_que
Fin
t=array([int(0)]*(n+1))
def insertion_tab_trié (x,t,n):
i=n
while t[i-1]> x :
t[i]=t[i-1]
i-=1
t[i]= x
procédure eclat_tableau_en2 ( @ T1,@T2, T:tab; n: entier)
Debut
j ← 0
k ← 0
pour i 0 à n-1 faire
si T[i] mod 2=0 alors
T1[j] ← T[i]
j ← j+1
sinon
T2[k] ← T[i]
k ← k+1
fin_pour
Fin
def Eclat(T1,T2,T,n):
global j,k
j,k=0,0
for i in range(n):
if t[i] %2==0:
T1[j]=T[i]
j=j+1
else:
T2[k]=T[i]
k=k+1
Fonction Occurrence( x : entier; T:tab; n : entier) : entier
Debut
nb ← 0
pour i de 0 à n-1 faire
nb ← nb+1
fin pour
retourner nb
Fin
def Occurrence (x,T,n) :
nb = 0
for i in range(n):
if (T[i] == x ) :
nb=nb+1
return nb
Fonction Rech_Seq( x:entier; T:tab; n : entier) : Booléen
Debut
i ← 0
tant que (t[i] ≠ x ) et ( i < n-1 ) faire
i←i+1
fin tant que
retourner t[i] = x
Fin
def Rech_Seq(x,T,n) :
i = 0
while (T[i] != x ) and ( i < n-1) :
i=i+1
return (T[i] == x)
Fonction Rech_dicho ( x:entier; T:tab; n : entier) : Booléen
Debut
i ← 0
tant que (t[i] ≠ x ) et ( i < n-1 ) faire
i←i+1
fin tant que
retourner t[i] = x
Fin
def existe (x,T,n) :
i = 0
while (T[i] != x ) and ( i < n-1) :
i=i+1
return (T[i] == x)
fonction alpha ( ch : chaîne) : booléen
Debut
i ← 0
tant que (i < long (ch)) et (« A » ≤ ch[i] ≤ « Z ») faire
i← i + 1
fin_tant que
retourner i = long (ch)
Fin
def alpha ( ch):
i= 0
while (i < len(ch)) et (« A » <= ch[i] <= « Z »)
i+=1
return i==len(ch)
fonction Espace_Superflux ( ch:chaîne) : chaîne
Debut
tant que (pos( » « ,ch) ≠ -1) faire
effacer (ch,pos( » « ,ch),pos( » « ,ch)+1)
fin_tant que
retourner ch
Fin
def espace_superflux ( ch):
while (ch.find( » « ) !=-1):
p=ch.find( » « )
ch= ch[:p]+ch[p+1:]
return ch
Fonction Occ_sans_doublons( ch : chaîne) : Booléen
Debut
Fin
def Occ_sans_doublons(ch) :
return …
fonction Premier ( n : entier) : booléen
Debut
i ← 0
tant que (n mod i ≠ 0) et (i < n div 2) faire
i ← i + 1
fin_tant que
retourner i = n div 2
Fin
def Premier ( n):
return test
fonction Facteurs_premier ( n) : entier
Debut
retourner …
Fin
def fact_premier(n):
i = 2
ch = « »
while n != 1:
if (n%i == 0):
ch = ch+str(i)+ »* »
n = n//i
else:
i = i+1
return ch[0:len(ch)-1]
fonction convertir_Base ( n, base : entier) : entier
Debut
i ← 2
ch ← « »
tant que n≠1 faire
si (n mod i = 0) alors
ch ← ch+str(i)+ »* »
n ← n//i
sinon
i ← i+1
fin tant que
retourner ( sous-chaîne ( ch, 0, long(ch)-1))
Fin
def Convert_base ( n,base):
chiffres = « 0123456789ABCDEF »
n_converti= « »
while n>0:
reste = n % base
n_converti= chiffres[reste] + n_converti
n = n // base
return n_converti
fonction combinaison ( n : entier) : entier
Debut
retourner ( sous-chaîne ( ch, 0, long(ch)-1))
Fin
def Combinaison(n):
return(ch[0:len(ch)-1])
fonction PGCD ( a, b : entier) : entier
Debut
tant que b ≠ 0 faire
r=a%b
a=b
b=r
fin tant que
retourner a
Fin
def pgcd(a,b):
while b!=0:
r=a%b
a=b
b=r
return a
fonction Factoriel ( n : entier) : entier
Debut
f ← 1
pour i de 1 à n faire
f ← f * i
fin pour
retourner f
Fin
def factoriel(n):
f = 1
for i in range(n):
f =f * i
return f