Révision

SPE

Chapitre 1. Tuple
T=(1,3,10,"ali")
for i in range(len(T)):
print(T[i])
Comiber une liste avec tuple

T=[("ali",20),("sami",19),("aziz",21)]
for i in range(len(T)):
print(T[i])
#un programme qui calcule la moyenne des ages
T=[("ali",20),("sami",19),("aziz",21)]
s=0
for i in range(len(T)):
s=s+T[i][1]
m=s/len(T)
#un programme qui calcule la moyenne des ages
T=[("ali",20),("sami",19),("aziz",21)]
s=0
for i T:
s=s+i[1]
m=s/len(T)
Pour créer un tuple qui contient une seul valeur

>>>T=(1,)

Pour creer un tuple vide on fait

>>>T=()
Chapitre 2. Dictionnaire

>>> D={}
>>>len(D)
0
>>>T={0:"un",1:"un",2:"deux"}
Parcours
Résulat
T={0:"un",1:"un",2:"deux"}

for i in T:
print(i)
Parcours

T={0:"zero",1:"un",2:"deux"} Résultat

for i in T:
print(i,T[i])
def liste_cles(D):
L=[]
for i in D:
L.append(i) # L=L+[i]
return L
def liste_valeurs(D):
L=[]
for i in D:
L.append(D[i]) # L=L+[D[i]]
return L
def Inverser(T):
D={}
for i in T:
D[T[i]]=i
return D

>>>R={0:"zero",1:"one",2:"two"}
>>>Inverser(D)
{"zero":0,"one":1,"two":2}
Chapitre 3. La récursivité
def suite_Re(n):
if n==0:
return 1
else:
return 2*suite_Re(n-1)
def fact_re(n):
if n==0:
return 1
else:
return n*fact_re(n-1)
def somme_it(n):
s=0
while n!=0:
s=s+n%10
n=n//10
return s
def somme_it(n): def somme_re(n):
s=0 if n==0:
while n!=0: return 0
else:
s=s+n%10 return n%10+suite_re(n//10)
n=n//10
return s
def fibo_re(n):
if n==0 or n==1:
return1
else:
fibo_re(n-1)+fibo_re(n-2)
def sommeElt(L):
s=0
for i in range(len(L)):
s=s+L[i]
return s
####
def sommeElt_re(L):
if L==[]:
return 0
else:
return L[0]+sommeElt_re(L[1:])
def occurence(L,x):
cpt=0
for i in range(len(L)):
if L[i]==x:
cpt=cpt+1
return cpt
####
def occurence_re(L,x):
if L==[]:
return 0
elif L[0]==x:
return 1+occurence_re(L[1:])
else:
return 0+occurence_re(L[1:])

Chapitre 4. Pile /File
## Les primitives
def Empiler(P,x):
P.append(x)#P=P+[x]
def PileVide(): return P
P=[] #####
return P def depiler(P):
#### P.pop() # P=P[0:-1]
def EstVide(P): return P
####
if P==[]: def SommetPile(P):
return True if P==[]:
else: return "Pile vide"
return False else:
return P[-1]
On va utiliser une pile pour vérifier la parenthésage d'une
chaîne de caractères
Chapitre 5. les alorithmes de tri

1. Tri sélection
def tri_selection(T):
for i in range(len(T)-1):
posmin=i
for j in range(i+1,len(T)):
if T[j]<T[posmin]:
posmin=j
#permutation
T[i],T[posmin]=T[posmin],T[i]
return T
2. Tri par bulle
3. Tri par insertion
4. Tri fusion
5. Tri rapide
Chapitre 6. Les arbres binaires
Pour implémenter un arbre on utilise une liste de
listes

Un arbre est structure récursive

arbre binaire de recherche
Créer un arbre binaire de recherche à partir d'une liste
chapitre 7. les graphes
 Villes=["casa","Rabat","fes","taza"]
Implémentation d'un graphe
2. on utilise une matrice d'adjacence