Python_1

Exercices en python pour CPGE

Veuillez SVP télécharger Exercices en python pour CPGE afin de respecter l’indentation

La liste des exercices corrigés en python

Équation second degré

# Télécharger fichier :    https://www.4shared.com/file/y7bnOoFWei/equationSecondOrdre.html?

from math import *
recommencer=0
while recommencer!=1:
print ("Programme qui calcule les racines d'un polynome du second degre ")
print (" Ax^2 + Bx + C=0")
A=float(input('A='))
B=float(input('B=') )
C=float(input('C=') )
delta=B*B-4*A*C
print ("Delta=",delta )
if delta <0: print ("Pas de solutions") if delta ==0: print ("Une solution double" ) x=-B/2*A print ("X=",x ) if delta >0:
print ("Deux solutions")
x1=(-B+sqrt(delta) )/(2*A)
x2=(-B-sqrt(delta) )/(2*A)
print ("X1=",x1 )
print ("X2=",x2 )
print ("Fin du programme!")
print ("Voulez-vous recommencer ?")
recommencer=int(input('0. Ouin1. Nonn'))

hexadecimal to decimal

# Télécharger fichier :      http://cuon.io/programme

# convertir Hex en decimal
import math

def SOMME_Puiss(L):
somme=0
k=0
for i in L:
somme+=i*math.pow(16,k)
k+=1
return somme
def decod(L):
L1=[]
for i in L:
if i=='A':
L1=L1+[10]
elif i=='B':
L1=L1+[11]
elif i=='C':
L1=L1+[12]
elif i=='D':
L1=L1+[13]
elif i=='E':
L1=L1+[14]
elif i=='F':
L1=L1+[15]
else:
L1=L1+[int(i)]

return L1

n='A4F5B'
L=list(n)
print(L)
L=L[::-1]
print(L)
R1=[]
R1=decod(L)
print(R1)
print(n,'----> ',int(SOMME_Puiss(R1)))

octal to decimal

# Télécharger fichier :     https://www.4shared.com/office/2T9301zJei/OctToDec.html?

# convertir Octal en decimal
import math
def splitter(n):
T=[]
while n!=0:
q=n%10
T=T+[q]
n=n//10
return T
def SOMME_Puiss(L):
somme=0
k=0
for i in L:
somme+=i*math.pow(8,k) #Pour convertir BIN en Decimal tu change 8 en 2
print('k= ',k,' i= ',i, ' somme= ',somme)
k+=1
return somme
n=1454
'''
F=list(str(n))
print ('F= ',F)
F=F[::-1]
print ('F= ',F)
'''
L=[]
L=splitter(n)
print(L)
somme=SOMME_Puiss(L)
print(n,"-->",somme)

decimal to binary

# Télécharger fichier : https://www.4shared.com/office/0IAzjmIica/DecToBin.html?

nombre=int(input("donner un nombre "))
i,b,q=0,0,1
while(q != 0):
b+=(nombre%2)*(10**i)
nombre=nombre//2
q=nombre
i+=1
print("ce nombre en binaire est " ,b)

Calcul puissance recursive et itérative

# Télécharger fichier  https://www.4shared.com/office/Gq3zyrsCei/puissance.html?

def puiss1(x,y):
p=1
for i in range(1,y+1):
p*=x
return p
def puiss2(x,y):
if y==0:
return 1
else:
return puiss2(x,y-1)*x
print(puiss1(3,4))
print(puiss2(3,4))

Calcul partie entière , pgdc et ppmc (itérative)

# Télécharger fichier :     https://www.4shared.com/office/GYG0Wazsca/ppmc_iterative.html

def ppmc(a,b):
n,p=a,b
while a!=b:
if a0:
b=0
while x-1>=0:
x-=1
b+=1
else:
b=-1
while x+1<0:
x+=1
b-=1
return b

a,b=15,25

print(ppmc(a,b))
print (pgdc(15,25))
print(entiere(4.24))
print(entiere(-4.24))

Pgdc recursive

# Télécharger fichier https://www.4shared.com/office/jRm69vQLei/pgcd_Rcursive.html?

def pgcd(x,y):
if x>y:
return pgcd(x-y,y)
elif x<y:
return pgcd(x,y-x)
else :
return x
print(pgcd(25,15))

décomposer un nombre et le stocker dans une liste

# Télécharger fichier  : https://www.4shared.com/office/hra5g65Nei/subdiviser_un_nombre.html?

n=int(input("donner nb: " ))
L=[]
i=0
while (n%10>0):
r=n%10
n=n//10
print(i," ",r," ",n)
L=L+[r]
i=i+1
L=L[::-1]
print(L)

Trie à bulle (sort list)

# Télécharger fichier  : https://www.4shared.com/office/FrqoHnVEei/Trie_Bulle.html?

t=[3,12,21,45,122,78,64,53,89,24,84,46]
echange=True
while echange:
echange=False
for i in range(0,11):
if t[i]>t[i+1]:
temp=t[i]
t[i]=t[i+1]
t[i+1]=temp
echange=True
print (t )

trie selection (sort list selection)

# Télécharger fichier  : https://www.4shared.com/office/sDvSvUMRei/Trie_Selection.html?

t=[3,12,21,45,122,78,64,53,89,24,84,46]
for i in range(0,11):
pos=i
for j in range(i+1,12):
if t[pos]>t[j]:
pos=j
if pos!=i:
temp=t[i]
t[i]=t[pos]
t[pos]=temp

print (t )

Fonction permuter deux nombres

# Télécharger fichier:  https://www.4shared.com/office/2AFrq6FQei/permuter.html?

def swap2(x,y):
x,y=y,x
return x,y
a,b=20,40
Z=swap2(20,40)
print(a,b)
print(Z[0],Z[1])

Somme de deux listes

# Télécharger fichier: https://www.4shared.com/office/gz6BPGIqei/som2list.html?

a=[1,2,3,4]
b=[10,20,30,40]
c=[]
for i in range(4):
c+=[a[i]+b[i]]
print(c)

chaine palindrome de deux méthodes

# Télécharger fichier: https://www.4shared.com/office/XN_tRGarca/palindrome2.html?

#-------------------------------------------------------------------------------
# palindrome
#
#-------------------------------------------------------------------------------

def palindrome1(x):
if x[::]==x[::-1]:
return True
else:
return False
def palindrome2(x):
ln=len(x)
m=ln//2
p=True
for i in range(0,m+1):
if x[i]!=x[ln-1-i]:
p=False
break
return p

l=[2,4,3,1,6,7,9]
print(palindrome1(l))
print(palindrome2(l))
s="aziza"
e=[]
for i in s:
e+=[i]
print(palindrome1(e))
print(palindrome2(e))

suite fibonacci

# Télécharger fichier:  https://www.4shared.com/office/I61uoVW5ca/fibo.html?

 

#-------------------------------------------------------------------------------

# Chaque terme de la suite de Fibonacci

#est obtenu en ajoutant les deux termes pr?c?dents.

# Les premiers termes sont:

#F0=0,F1=1,F2=1,F3=2,F4=3,F5=5,F6=8,F7=13,F8=21,?

#-------------------------------------------------------------------------------

def fib(n):

if n == 0:

return 0

elif n == 1:

return 1

else:

return fib(n-1) + fib(n-2)

print (fib(8))

Fonction min max ,puissance

# Télécharger fichier: https://www.4shared.com/office/-DxhLiTpca/fct1.html?

 

def somme(a,b):
s=a+b
return s

def soustraction(a,b):
d=a-b
return d
def produit(a,b):
p=a*b
return p
def puissance(a,b):
m=1
for i in range (b):
m=m*a
return m
def maxi(a,b):
if a>b :
f=a
elif b>a :
f=b
else :
f=a
return f

def mini(a,b) :
if a return a
elif b return b
else :
return a
a= int(input("a= "))
b= int(input("b= "))
c= int(input("c= "))
o= int(input("o= "))
s=somme(a,b)
d=soustraction(a,b)
p=produit(a,b)
m=puissance(a,b)
f=maxi(a,b)
k=mini(a,b)
w= maxi(c,maxi(a,b))
l=maxi(maxi(c,o),maxi(a,b))
print("s=",s)
print("d=",d)
print("p=",p)
print("m=",m)
print("f=",f)
print("k=",k)
print("w=",w)
print("l=",l)

Factoriel recursive

# Télécharger fichier: https://www.4shared.com/office/3l_8AO6mca/facto_recursivite.html?

def factorial( n ):
if n <1:
return 1
else:
return n * factorial( n - 1 )
def fact(n):
for i in range(1, n+1 ):
print ("%2d! = %d" % ( i, factorial( i ) ))
fact(6)

Conway

# Télécharger fichier: https://www.4shared.com/office/SiAGQIZWei/conway.html?

'''
0 1
1 11
2 21
3 1211
4 111221
5 312211
6 13112221
7 1113213211
8 31131211131221
9 13211311123113112211
10 11131221133112132113212221
'''
def Conway (X):
Solution = ''
Y = X[0]
n = 1
for I in X[1:]:
if I == Y:
n += 1
else:
Solution += str( n ) + Y
Y = I
n = 1
return Solution + str( n ) + Y

X = '1'
for i in range(11):
print(i,X)
X = Conway (X)

insérer nombre dans une liste avec class

# Télécharger fichier: https://www.4shared.com/office/UykGRpdbca/insererNombre_List_Class.html?

class inserer():
def __init__(self,L):
self.L=L
def ajouter(self,index,n):
self.L+=[0]
print(L)
for i in range(len(self.L)-1,index,-1):
self.L[i]=self.L[i-1]
self.L[index]=n
return self.L
L=[10,20,30,40]
index=-1
while index<0 or index>len(L)-1:
index=int(input("donner index "))
n=int(input("donner nb "))
t=inserer(L)
print(t.ajouter(index,n))

fonction à plusieurs arguments (*args)

# Télécharger fichier: https://www.4shared.com/office/WCfyqxr6ei/args.html?

def somme1(*args):
total = 0
for i in args:
total = total + i
print (str(total))
def multiply(*args):
res = 1
for i in args:
res = res * i
return res

somme1(2,3)
somme1(2,3,4,5)

print (multiply(1, 2, 3, 4))

parcourir un dictionnaire

# Télécharger fichier: https://www.4shared.com/office/IOTHXLJIca/parcourirDic.html?

print("DICTIONNAIRE")
d = {"Rabat":[5,6,4],"Fes":[3,5,3],"Marrakech":[4,7,2],"safi":[6,11,2]}
for key in d:
print(key," ",d[key])
for i in range(len(d[key])):
print (d[key][i])

lambda

# Télécharger fichier: https://www.4shared.com/office/Hr12k84ica/Fct_anonyme.html?

def f(x):
return x*2

print (f(3))

g = lambda x: x*2
print (g(3))

Etoile 1

# Télécharger fichier: https://www.4shared.com/office/wppOMD1Fei/etoile1.html?

"""
*
**
***
****
*****
******
*******
"""
for a in range(1,8):
print ("*"*a)

Etoile 2

# Télécharger fichier: https://www.4shared.com/office/mtabLTRFca/etoile2.html?

"""
*
**
***
****
*****
"""
import time
esp=7
for a in range(1,6):
print (' '*esp,'*'*a)
time.sleep(1)
esp=esp-1

Etoile 3

# Télécharger fichier:  https://www.4shared.com/office/u4wNhtf4ca/etoile3.html?

"""
*
***
*****
*******
*********
***********
"""
esp=6
et=0
for a in range(1,7):
print (' '*esp,'*'*(2*et+1))
time.sleep(1)
esp=esp-1
et=et+1

conversion Dict to string , et vice versa

# Télécharger fichier: https://www.4shared.com/office/mUR2y7y8ei/_dict1.html?

S="ABC"

L=['A','B','C']

D={0:'A',1:'B',2:'C'}

print("affichage contenu S ")

for c in S:

print (c)

print("affichage contenu L ")

for i in L:

print (i)

print("affichage contenu D ")

for c in D:

print (c)

#donc pour afficher key et contenu de dict:

print("affichage key + contenu D ")

for key in D:

print (key,'----',D[key])

#conversion string to list

print("conversion string to list")

Al=[]

for c in S:

Al+=c

print (Al)

#conversion string to list

print("conversion string to dict")

Dl,k={},0

for c in S:

Dl[k]=c

k+=1

print (Dl)

#conversion string to list

print("conversion dict to string")

Dt={0:"s",1:"a",2:"l",3:"m",4:"a"}

st=""

for key in Dt:

st+=Dt[key]

 

print (st)

année bissextile et calculer le jour suivant une date

# Télécharger fichier: https://www.4shared.com/office/gPHw3gb0ca/annee_bissextile.html?

'''

l'année sera bissextile (elle aura 366 jours):

si l'année est divisible par 4 et non divisible par 100,(exemple 2100 : non bissextille)

ou

si l'année est divisible par 400.

'''

# fonction qui retourne si une année est bissextille ou pas

def annee_bissextile(an):

b=( an%400==0 or (an%4==0 and (an%100)!=0));

return b

#-------------------------------------------------------------

#controle saisi jour ( entre 0 et 31) mois(entre 0 et 12) annee (entre 0 et l infinie)

def Control_saisi(x,y):

while True:

A=input("Entrez %s "%(y) )

if A.isdigit():

A=int(A)

if A>=0 and A<=x:

break

print ("vous avez fait une erreur, recommencez" )

return A

#----------------------------------------------------

m1=[1,3,5,7,8,10,12]

m2=[4,6,9,11]

jour=int(Control_saisi(31,"jour"))

mois=int(Control_saisi(12,"mois"))

annee=int(Control_saisi(400000,"annee"))

if mois==2:

if annee_bissextile(annee):

jr=29

else:

jr=28

if mois in m1:

jr=31

elif mois in m2:

jr=30

else:

print("saisi erronée")

if jour==jr:

if mois==12:

j,m=1,1

a=annee+1

else:

j=1

m=1

a=annee

else:

j=jour+1

m=mois

a=annee

print("jour suivant =%d / %d / %d "%(j,m,a))

 

commander une led par Arduino (déjà vérifier sur maquette Arduino )

# Télécharger fichier: https://www.4shared.com/office/VtfJI8Zoei/arduino_Led.html?

import serial

ser = serial.Serial(port ='COM7',baudrate = 9600,parity = serial.PARITY_ODD,stopbits = serial.STOPBITS_TWO, bytesize = serial.EIGHTBITS)

choix="0";

while choix !=2:

choix=input("1---allume n0----etteintn2---quittern")

if choix !="2":

ser.write(choix);

ser.close()

 

Bisection, Secant & Newton Raphson Method

# Télécharger fichier: https://www.4shared.com/office/fnmbqKBkei/Bisection_Secant__Newton_Raphs.html?

"""

Bisection, Secant & Newton Raphson Method.

"""

 

import math

"""

* Variable Description:

*

* f : Given function

* f_ : Derivative of f

* [a, b] : End point values

* TOL : Tolerance

* NMAX : Max number of iterations

"""

 

# https://gist.github.com/swvist/3775568

def bisection(f, a, b, TOL=0.001, NMAX=100):

"""

Takes a function f, start values [a,b], tolerance value(optional) TOL and

max number of iterations(optional) NMAX and returns the root of the equation

using the bisection method.

"""

n=1

while n<=NMAX:

c = (a+b)/2.0

print ("a=",a,"tb=",b"tc=",c,"tf(c)=",f(c))

if ((f(c)==0 ) or ((b-a)/2.0 < TOL)) :

return c

else:

n = n+1

if f(c)*f(a) > 0:

a=c

else:

b=c

return False

 

def secant(f,x0,x1, TOL=0.001, NMAX=100):

"""

Takes a function f, start values [x0,x1], tolerance value(optional) TOL and

max number of iterations(optional) NMAX and returns the root of the equation

using the secant method.

"""

n=1

while n<=NMAX:

x2 = x1 - f(x1)*((x1-x0)/(f(x1)-f(x0)))

if x2-x1 < TOL:

return x2

else:

x0 = x1

x1 = x2

return False

 

def newtonraphson(f, f_, x0, TOL=0.001, NMAX=100):

"""

Takes a function f, its derivative f_, initial value x0, tolerance value(optional) TOL and

max number of iterations(optional) NMAX and returns the root of the equation

using the newton-raphson method.

"""

n=1

while n<=NMAX:

x1 = x0 - (f(x0)/f_(x0))

if x1 - x0 < TOL:

return x1

else:

x0 = x1

return False

 

if __name__ == "__main__":

 

def func(x):

"""

Function x^3 - x -2

We will calculate the root of this function using different methods.

"""

return math.pow(x,3) - x -2

 

def func_(x):

"""

Derivate of the function f(x) = x^3 - x -2

This will be used in Newton-Rahson method.

"""

return 3*math.pow(x,2)-1

 

#Invoking Bisection Method

res = bisection(func,1,2)

print (res)

 

#Invoking Secant Method

res = bisection(func,1,2)

print (res)

 

#Invoking Newton Raphson Method

res = newtonraphson(func,func_,1)

print ("res=",res)

copie par référence et par valeur

# Télécharger fichier: https://www.4shared.com/office/y1vPrLLAei/copieValeur-ref.html?

l1=[1,2,3,4]

l2=l1 # copie par reference

l2[0]=10

print (l1, "  ",l2)

 

l3=l1[:] # copie par valeur

l3[0]=100

print (l1, "  ",l3)

calcul déterminant d'une matrice

# Télécharger fichier: https://www.4shared.com/office/4ruW1zNJei/calcul_determinant_test.html?

matrice=[[1,0,0,0,0],[0,2,0,0,0],[0,0,3,0,0],[0,0,0,4,0],[0,0,0,0,5]]

def matrice_cut(m,i):

mbis=[list(j) for j in m]

coef=mbis[i][0]

mbis.remove(mbis[i])

for k in mbis:

k.remove(k[0])

return coef,mbis

def determinant(m):

det=0

if len(m)==1:

det=m[0]

elif len(m)==2:

det=m[0][0]*m[1][1]-m[1][0]*m[0][1]

else:

for j in range(0,len(m)):

mem=matrice_cut(m,j)

det=det+(((-1)**j)*mem[0]*determinant(mem[1]))

return det

 

print (determinant(matrice))

appelle fonction suivant index list

# Télécharger fichier: https://www.4shared.com/office/NVFrzOVmca/call_a_function_from_a_list.html?

def func1():return 1

def func2():return 2

def func3():return 3

fl = [func1,func2,func3]

print(fl[0]())

print(fl[1]())

 

print(fl[2]())

codage cesar

# Télécharger fichier: https://www.4shared.com/office/bDK24dzeei/cesar.html?

import string

class cesar:

def __init__(self,d):

self.d=d

def coder(self,msg):

msg1=""

msg=msg.upper()

S=string.ascii_uppercase # creer auto les alphabet

# stocker S dans un dict ---> Al

Al,k={},0

for c in S:

Al[k]=c

k+=1

print("Al= ",Al)

for key in Al:

print (key,Al[key])

#Recherche des carateres de Sl ( qui est en faite msg ) dans Al ( qui est en faite S) : puis codage

for c in msg:

for key in Al:

if c==Al[key]:

print(c,'------> ',Al[(key+self.d)%26])

msg1=msg1+Al[(key+self.d)%26]

return msg1

#test 1

MSG="abc"

c1=cesar(-2)#deplacement negatif

print(MSG,'---------> ',c1.coder(MSG))

#test 2

MSG="xyz"

c1=cesar(4)

print(MSG,'---------> ',c1.coder(MSG))

 

codage casar avec fichier

# Télécharger fichier: https://www.4shared.com/office/4ErdUo8Xei/cesar_avec_fichier.html?

import string,os

class cesar:

def __init__(self,d):

self.d=d

def coder(self,msg):

msg1=""

msg=msg.upper()

S=string.ascii_uppercase # creer auto les alphabet

# stocker S dans un dict ---> Al

Al,k={},0

for  c in S:

Al[k]=c

k+=1

print("Al= ",Al)

for key in Al:

print (key,Al[key])

 

#Recherche des carateres de Sl ( qui est en faite msg ) dans Al ( qui est en faite S) : puis codage

for c in msg:

for key in Al:

if c==Al[key]:

print(c,'------> ',Al[(key+self.d)%26])

msg1=msg1+Al[(key+self.d)%26]

return msg1

def decoder(self,msg):

msg1=""

msg=msg.upper()

S=string.ascii_uppercase # creer auto les alphabet

# stocker S dans un dict ---> Al

Al,k={},0

for  c in S:

Al[k]=c

k+=1

print("Al= ",Al)

for key in Al:

print (key,Al[key])

 

#Recherche des carateres de Sl ( qui est en faite msg ) dans Al ( qui est en faite S) : puis codage

for c in msg:

for key in Al:

if c==Al[key]:

print(c,'------> ',Al[(key-self.d)%26])

msg1=msg1+Al[(key-self.d)%26]

return msg1

def coder_fichier(self,fichier):

#lire le contenu du fichier

#os.chdir("d:/exercice1")

mon_fichier = open(fichier, "r")

contenu = mon_fichier.read()

mon_fichier.close()

#stocker le contenu apres codage dans  fichier coder.txt

mon_fichier = open("coder.txt", "w")

mon_fichier.write(self.coder(contenu))

mon_fichier.close()

def decoder_fichier(self,fichier):

#lire le contenu du fichier

os.chdir("d:/exercice1")

mon_fichier = open(fichier, "r")

contenu = mon_fichier.read()

mon_fichier.close()

#stocker le contenu apres codage dans  fichier coder.txt

mon_fichier = open("decoder.txt", "w")

mon_fichier.write(self.decoder(contenu))

mon_fichier.close()

 

 

 

#test 1

MSG="abc"

c1=cesar(2)

print(MSG,'---------> ',c1.coder(MSG))

#test 2

MSG1="xyz"

c2=cesar(4)

print(MSG1,'---------> ',c2.coder(MSG1))

 

#test FICHIER

#lire   fichier et le stocker dans variable contenu

c3=cesar(2)

fichier="fichier1.txt"

c3.coder_fichier(fichier)

fichier="coder.txt"

c3.decoder_fichier(fichier)

 

 

class: maxi_mini_len_strip,sort_joint_split_count

# Télécharger fichier: https://www.4shared.com/office/gQfNod15ei/LesFct_maxi_mini_len_stripsort.html?

str = " salma"

print(str.index('s'))

######################################## class STR

class STR:

def __init__(self,chaine):

self.chaine=chaine

def STRINDEX(self,c):

p=-1

for i in range(len(str)):

if str[i]==c:

p=i

return p

def STRCOUNT(self,c):

p=0

for i in range(len(str)):

if str[i]==c:

p+=1

return p

def STRCOUNTE(self,c,n1,n2):

p=0

if n2>len(self.chaine):

n2=len(self.chaine)

for i in range(n1,n2):

if str[i]==c:

p+=1

return p

def JOINT(self,c):

print("ok")

ss=""

for i in self.chaine:

ss+=i+c

return ss

def SORT(self):

N = len(self.chaine)

Changement = True

while Changement :

Changement = False

for i in range(N-1):

if self.chaine[i] > self.chaine[i+1]:

self.chaine[i] , self.chaine[i+1]=self.chaine[i+1],self.chaine[i]

Changement = True

return self.chaine

def LEN(str):

p=0

for i in str:

p+=1

return p

def STRIP(self,c):#str3 = "0000000LYDEX BENGRERIR0000000";

s=""

for i in self.chaine:

if i!=c:

s+=i

self.chaine=s

return self.chaine

############################### a bulle

class LIST:

def __init__(self,L):

self.L=L

def SORT(self):

N = len(self.L)

Changement = True

while Changement :

Changement = False

for i in range(N-1):

if self.L[i] > self.L[i+1]:

self.L[i] , self.L[i+1]=self.L[i+1],self.L[i]

Changement = True

return self.L

def maxi(self):

m=self.L[0]

for i in range(len(self.L)):

if self.L[i]>m:

m=self.L[i]

return m

def mini(self):

m=self.L[0]

for i in range(len(self.L)):

if self.L[i]<m:

m=self.L[i]

return m

def Inverse_Pile(self):

for i in range((len(self.pile))//2):

self.pile[i], self.pile[len(self.pile)-1-i]= self.pile[len(self.pile)-1-i], self.pile[i]

###################

str1=STR(" salma")

print(str1.STRINDEX('s'))

print(str1.STRCOUNT('a'))

print(str1.STRCOUNTE('a',5,8))

L=[2,10,3,7]

L.sort()

print(L)

######################## TRI a bulle

T=[2,20,1,8,0,3 ]

print("T avant ",T)

T=LIST(T)

print("T apres",T.SORT())

print("maxi= ",T.maxi())

print("maxi= ",T.mini())

###################################### len

print(STR.LEN("salma"))

print(STR.LEN(T.L))

############################################ joint

s=STR('salma')

print(s.JOINT('*'))

############################" STRIP

str3 = "0000000LYDEX BENGRERIR0000000";

str3=STR(str3)

print(str3.chaine)

print(str3.STRIP( '0' ))

Pile et File

# Télécharger fichier: https://www.4shared.com/office/Gz95zZO8ca/pile_file.html?

class Pile:

def __init__(self):

self.pile = []

def SOM_P(self):

try:

return self.pile[-1]

except Exception as e:

print ("Error:", e)

 

def Empiler(self, element):

return self.pile.append(element)

 

def Depiler(self):

try:

return self.pile.pop()

except Exception as e:

print ("Error:", e)

 

def PileVide(self):

if self.pile == []:

return True

else:

return False

 

def AfficherPile(self):

for i in self.pile:

print (i)

print('------------------')

 

 

class File:

 

def __init__(self):

self.file = []

 

def Enfiler(self, element):

return self.file.append(element)

 

def Defiler(self):

try:

return self.file.pop(0)

except Exception as e:

print ("Error:", e)

 

def AfficherFile(self):

for i in self.file:

print (i)

print('------------------')

p=Pile()

p.AfficherPile()

x=p.Empiler(4)

p.AfficherPile()

x=p.Empiler(8)

x=p.Empiler(9)

x=p.Empiler(2)

p.AfficherPile()

x=p.Depiler()

p.AfficherPile()

x=p.Depiler()

p.AfficherPile()

x=p.Depiler()

p.AfficherPile()

x=p.Depiler()

p.AfficherPile()

print("===============================")

f=File()

f.Enfiler(4)

f.AfficherFile()

f.Enfiler(8)

f.Enfiler(5)

f.Enfiler(1)

f.AfficherFile()

f.Defiler()

print("-----------------------------------")

f.AfficherFile()

Class Rotation à droite et à gauche d'une liste

# Télécharger fichier:  https://www.4shared.com/office/TelM7Wdvei/rotation_List__class.html?

class rotation():

def __init__(self,L):

self.L=L

def rotation1(self):

l=len(self.L)

n=self.L[l-1]

for i in range(l-1,0,-1):

self.L[i]=self.L[i-1]

self.L[0]=n

return self.L

def rotation2(self):

l=len(self.L)

n=self.L[0]

for i in range(1,l):

self.L[i-1]=self.L[i]

self.L[l-1]=n

return self.L

def longueur(self):

return len(self.L)

L=[2,3,4,5,9]

r=rotation(L)

print(r.longueur())

print(r.rotation1())

print(r.rotation2())

print(r.rotation2())

 

notation_polonaise

# Télécharger fichier:    https://www.4shared.com/office/XOO_zfQCca/notation_polonaise_python1.html?

 

def to_rpn(s):

print('s= ',s)

rpn = []

zstr = [None] * 20

top = -1

for c in s:

if c.islower() or c.isdigit():

rpn.append(c)

 

elif c=='(':

pass

elif c==')':

rpn.append(zstr[top])

#print ('zstr[top] =',zstr[top])

top -= 1

else:

#print('c---> ',c)

top += 1

zstr[top] = c

rpn.append(zstr[top])

return ' '.join(rpn)

#--------------------------------------------------------------------------------------------------------

def operation(x,y,char):

if char=='+':

return x+y

elif char =='-':

return x-y

elif char =='*':

return x*y

elif char =='/':

return x/y

def calcul(L):

pile=[]

i=0

while i<len(L):

if isinstance(L[i],int):

pile.append(L[i])

i+=1

#print(L[i])

else:

y=pile.pop()

x=pile.pop()

z=operation(y,x,L[i])

pile.append(z)

i+=1

#print(pile)

return z

#------------------------------------------------------------------------------------------------------------------

 

 

def main():

print('1---------------------------------------')

rpn = to_rpn("(x-y)/((a+b)*(c+d))")

print (rpn)

 

print('2---------------------------------------')

rpn = to_rpn("(8-2)/((4+2)*(3+2))")

print (rpn)

 

 

print('3---------------------------------------')

u=(3,4,6,'*','+')

print(calcul(u))

print('4---------------------------------------')

u=[6, 2, '-', 4, 2, '+', 6, 2, '+', '*', '/']

print(calcul(u))

 

 

 

if __name__ == '__main__':

main()

 

 

'''

TOKENS = {

'+': lambda a, b: a + b,

'-': lambda a, b: a - b,

'*': lambda a, b: a * b,

'/': lambda a, b: a / b,

'^': lambda a, b: a ** b,

'**': lambda a, b: a ** b,

'%': lambda a, b: a % b,

'mod': lambda a, b: a % b,

'//': lambda a, b: a // b

}

 

 

'''

exercice de synthèse

#telechaeger : https://www.4shared.com/office/cpzumgCPei/Tolkhyss.html?

#>{5} : justify a gauche de 5

#<{5} : justify a droite de 5

#^{5} : centrer 5 a droite et a gauche

'''

1 * 1     =     1

11 * 11    =    121

111 * 111   =   12321

1111 * 1111  =  1234321

11111 * 11111 = 123454321

 

9 x 1          +     2      = 11

9 x 12         +     3      = 111

9 x 123        +     4      = 1111

9 x 1234       +     5      = 11111

9 x 12345      +     6      = 111111

9 x 123456     +     7      = 1111111

9 x 1234567    +     8      = 11111111

9 x 12345678   +     9      = 111111111

 

9 x 9          +     7      = 88

9 x 98         +     6      = 888

9 x 987        +     5      = 8888

9 x 9876       +     4      = 88888

9 x 98765      +     3      = 888888

9 x 987654     +     2      = 8888888

9 x 9876543    +     1      = 88888888

 

'''

def Talkhys1(nb=5):

val = 0

for ind in range(nb):

val = val*10 + 1

print("{0: >{2}} * {0: <{2}} = {1:^{3}}".format(val, val**2, nb, 2*nb))

 

def Talkhys2(nb=8):

v=0

for i in range(1,9):

v=v*10+i

print("{0} x {1: <{4}} + {2:^{4}} = {3}".format(9,v,i+1,9*v+i+1,nb+2,1) )

def Talkhys3(nb=8):

v=0

for i in range(9,2,-1):

v=v*10+i

print("{0} x {1: <{4}} + {2:^{4}} = {3}".format(9,v,i-2,9*v+i-2,nb+2,1) )

Talkhys1()

print("")

Talkhys2()

print("")

Talkhys3()

print

Les nombres de Talkhys