changed the file's locations and added sqlite tests
This commit is contained in:
@@ -0,0 +1,8 @@
|
||||
|
||||
import os
|
||||
|
||||
db_user = os.environ.get('DB_USER')
|
||||
db_password = os.environ.get('DB_PASSWORD')
|
||||
|
||||
print(db_user)
|
||||
print(db_password)
|
||||
@@ -1,130 +0,0 @@
|
||||
import random
|
||||
|
||||
"""Partie 1: Tri par sélection."""
|
||||
|
||||
def reperer(liste,n):
|
||||
"""Repere la position du plus grand element parmi les n premiers elements d'une liste."""
|
||||
maximum=liste[0] #Affecte a maximum la valeur du premier élément de la liste.
|
||||
position=0 #Affecte a position la valeur de 0.
|
||||
for i in range(1,n): #Fait varier les valeurs de i de 1 à n.
|
||||
if liste[i]>maximum: #Verifie si la ie valeur de la liste est supérieur a la valeur de maximum.
|
||||
maximum=liste[i] #Si oui, affecte a maximum la valeur du ie valeur de la liste.
|
||||
position=i #Recupere la position de cet élément.
|
||||
return position #Renvoie la position de cet élément.
|
||||
|
||||
def echanger(liste,position1,position2):
|
||||
"""Echange 2 éléments d'une liste de positions données."""
|
||||
valeur=liste[position1] #Affecte a valeur la valeur de position1e terme de la liste.
|
||||
liste[position1]=liste[position2] #Mets en position1 le position2e terme de la liste.
|
||||
liste[position2]=valeur #Affecte au position2e terme de la liste la valeur de valeur.
|
||||
return liste #Renvoie la nouvelle liste de termes échangés.
|
||||
|
||||
def TriParSelection(liste):
|
||||
"""Tri une liste."""
|
||||
for n in range(len(liste)-1,0,-1): #Fait varier les valeurs de n de len(liste)-1 à 1.
|
||||
r=reperer(liste,n) #Recupere la position du plus grand élément parmi les n premiers.
|
||||
liste=echanger(liste,n,r) #Echange les éléments de position n et r.
|
||||
return liste #Renvoie la liste triée.
|
||||
|
||||
def test(a,b,taille,nombre=10):
|
||||
"""Test:"""
|
||||
for i in range(nombre): #Fait nombre tests et affiche les résultats.
|
||||
liste=[random.randint(a,b) for i in range(taille)]
|
||||
print("Test:",i+1)
|
||||
print(liste)
|
||||
print(principale(liste))
|
||||
print("")
|
||||
|
||||
#test(0,10,100)
|
||||
|
||||
"""Partie 2: Tri par insertion
|
||||
|
||||
10)
|
||||
ALGORITHME: TRIPARINSERTION:
|
||||
|
||||
DONNES: L :
|
||||
LT <- []
|
||||
POUR i DE 0 JUSQU A LA LONGUEUR DE LA LONGUEUR DE L FAIRE
|
||||
AJOUTER A LT LA VALEUR L[i]
|
||||
k <- i
|
||||
cle <- LT[-1]
|
||||
TANT QUE cle<LT[k-1] and k>0 FAIRE
|
||||
LT[k] <- LT[k-1]
|
||||
k <- k-1
|
||||
FIN TANT QUE
|
||||
LT[k] <- cle
|
||||
FIN POUR
|
||||
AFFICHER LT
|
||||
|
||||
11)
|
||||
"""
|
||||
def TriParInsertion(L):
|
||||
"""Tri une liste par insertion."""
|
||||
LT=[]
|
||||
#Recupere les éléments de L et les ajoute dans LT de façon a ce que LT soit triée
|
||||
for i in range(len(L)):
|
||||
#Ajoute la valeur de L considérée et stocke la valeur de la clé
|
||||
LT.append(L[i])
|
||||
k=i
|
||||
cle=LT[-1]
|
||||
#Décale la valeur de la clé dans LT tant que la clé est supérieur a ses éléments en partant de la fin
|
||||
while cle<LT[k-1] and k>0:
|
||||
LT[k]=LT[k-1] #Réaffecte la valeur de l'élément k a la valeur de l'élément k-1.
|
||||
k-=1
|
||||
#Une fois que l'on trouve que la clé est inférieure à un élément ou que l'on a considéré tous les éléments de LT
|
||||
LT[k]=cle
|
||||
#Renvoie la liste triée
|
||||
return LT
|
||||
|
||||
"""
|
||||
13) Justesse du tri par sélection
|
||||
|
||||
Algorithme: Reperer
|
||||
Pas de boucle
|
||||
|
||||
Algorithme: Echanger
|
||||
Pas de boucle
|
||||
|
||||
Algorithme: TriParSelection
|
||||
Invariant de boucle: ...
|
||||
|
||||
Algorithme: Test
|
||||
Invariant de boucle: ...
|
||||
|
||||
|
||||
14) Justesse du tri par insertion
|
||||
|
||||
Algorithme: Tri par insertion
|
||||
Invariant de boucle: ...
|
||||
|
||||
|
||||
15)
|
||||
"""
|
||||
|
||||
def TriParInsertionEtComplexite(L):
|
||||
complexite=0
|
||||
LT=[]
|
||||
complexite+=1
|
||||
for i in range(len(L)):
|
||||
LT.append(L[i])
|
||||
k=i
|
||||
cle=LT[-1]
|
||||
complexite+=4
|
||||
while cle<LT[k-1] and k>0:
|
||||
LT[k]=LT[k-1]
|
||||
k-=1
|
||||
complexite+=4
|
||||
complexite+=1
|
||||
LT[k]=cle
|
||||
complexite+=1
|
||||
complexite+=1
|
||||
return [LT,complexite]
|
||||
|
||||
|
||||
#16)
|
||||
|
||||
L=[random.randint(0,10) for e in range(100)]
|
||||
|
||||
Trie,complexite=TriParInsertionEtComplexite(L)
|
||||
print("Liste triee:",Trie)
|
||||
print("Complexite:",complexite)
|
||||
@@ -1,164 +0,0 @@
|
||||
import random
|
||||
|
||||
#1
|
||||
A= [[1,2,-1],
|
||||
[-2,0,3],
|
||||
[4,1,-1]]
|
||||
|
||||
|
||||
print("Matrice:",A)
|
||||
|
||||
#2
|
||||
#print(A[1])
|
||||
|
||||
#3
|
||||
#print(A[1][2])
|
||||
|
||||
#4
|
||||
#print(A[:][1])
|
||||
|
||||
#5a
|
||||
def MatNulle(n,p):
|
||||
"""Cree la matrice nulle de taille np."""
|
||||
return [[0 for j in range(p)] for i in range(n)]
|
||||
|
||||
#5b
|
||||
print("Matrice Nulle de taille (n,p):",MatNulle(3,4))
|
||||
|
||||
#5c
|
||||
def MatNulleBis(n,p=None):
|
||||
"""Cree la matrice nulle de taille np."""
|
||||
if not p: p=n
|
||||
return [[0 for j in range(p)] for i in range(n)]
|
||||
|
||||
|
||||
#5d
|
||||
print("Matrice nulle carre:",MatNulleBis(5))
|
||||
|
||||
#5e
|
||||
def MAlea(k,n,p=None):
|
||||
"""Cree la matrice comporant n lignes, p colonnes et dont les coefficients sont des entiers aleatoires de [-k,k]."""
|
||||
if not p: p=n
|
||||
return [[random.randint(-k,k) for j in range(p)] for i in range(n)]
|
||||
|
||||
#6
|
||||
def Pivot(M,j):
|
||||
"""Renvoie l'index de la ligne i qui contient l'élément de la colonne M d'indice j qui a la plus grande valeur absolue."""
|
||||
m=abs(M[j][j])
|
||||
p=j
|
||||
for i in range(j+1,len(M)):
|
||||
t=M[i][j]
|
||||
if abs(t)>m:
|
||||
m=t
|
||||
p=i
|
||||
return p
|
||||
|
||||
print("pivot:",Pivot(A,0))
|
||||
|
||||
|
||||
#7
|
||||
def EchangerLigne(M,i,l):
|
||||
"""Permet d'echanger la i-eme ligne et la l-eme ligne de la matrice M."""
|
||||
M[i],M[l]=M[l],M[i]
|
||||
|
||||
|
||||
EchangerLigne(A,0,1)
|
||||
print(A)
|
||||
|
||||
#8
|
||||
def CombLigne(M,i,l,r):
|
||||
"""Permet de remplacer la ligne i de la matrice M par Li-r*Ll."""
|
||||
M[i]=[M[i][j]-r*M[l][j] for j in range(len(M[i]))]
|
||||
|
||||
#CombLigne(A,1,0,A[Pivot(A,0)][0])
|
||||
p=Pivot(A,0)
|
||||
print(p)
|
||||
EchangerLigne(A,0,p)
|
||||
print(A)
|
||||
CombLigne(A,1,0,A[1][0]/p)
|
||||
print("Combine les lignes i et l:",A)
|
||||
|
||||
|
||||
#9 Algorithme
|
||||
"""Pivot Triangulaire Sup:
|
||||
Donnees: M une matrice
|
||||
|
||||
l<-nombre de lignes de la matrice M
|
||||
Pour j de 0 a l-1 FAIRE:
|
||||
p<-Pivot de la matrice m a partir de la colonne 0
|
||||
Echanger les lignes j et p de la matrice M
|
||||
Pour i de j+1 a l-1 FAIRE:
|
||||
Realise Li <- Li-r*Lj pour la matrice M
|
||||
"""
|
||||
|
||||
|
||||
#9
|
||||
def PivotTriangulaireSup(M):
|
||||
"""Permet de triangulariser la matrice."""
|
||||
l=len(M)
|
||||
for j in range(l):
|
||||
p=Pivot(M,j)
|
||||
EchangerLigne(M,j,p)
|
||||
if p!=0:
|
||||
for i in range(j+1,l):
|
||||
CombLigne(M,i,j,M[i][j]/M[j][j])
|
||||
|
||||
#10
|
||||
|
||||
|
||||
def Afficher(B,precision=3):
|
||||
for i in range(len(B)):
|
||||
text=""
|
||||
for j in range(len(B[i])):
|
||||
text+=str(float(B[i][j]))[:precision]
|
||||
if j<len(B[i])-1:
|
||||
text+="|"
|
||||
print(text)
|
||||
|
||||
#11
|
||||
B=MAlea(5,5)
|
||||
PivotTriangulaireSup(B)
|
||||
print("Triangularise")
|
||||
Afficher(B)
|
||||
#print(B)
|
||||
|
||||
#12
|
||||
def MaxIndice(l):
|
||||
"""Renvoie la liste des indices des termes de la liste dans l'ordre croissant."""
|
||||
M=[[l[i],i] for i in range(len(l))]
|
||||
indices=[]
|
||||
for i in range(len(l)):
|
||||
p=M[i].index(min(M[i]))
|
||||
indices.append(M[p][1])
|
||||
del M[p]
|
||||
return [indices[-j-1] for j in range(len(indices))]
|
||||
|
||||
|
||||
a=[random.randint(0,100) for i in range(10)]
|
||||
print(a)
|
||||
print(MaxIndice(a))
|
||||
|
||||
#13
|
||||
|
||||
def TriTabCL(M,i):
|
||||
"""Permet de trie un tableau selon l'ordre croissant d'une ligne."""
|
||||
indices=MaxIndice(M[i])
|
||||
n,p=len(M),len(M[0])
|
||||
nM=MatNulle(n,p)
|
||||
for i in range(n):
|
||||
for j in range(p):
|
||||
nM[i][j]=M[i][indices[j]]
|
||||
|
||||
print("\n13:")
|
||||
C=MAlea(5,5)
|
||||
Afficher(C)
|
||||
print(C[2])
|
||||
print(MaxIndice(C[2]))
|
||||
TriTabCL(C,2)
|
||||
Afficher(C)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,138 +0,0 @@
|
||||
#Représentation des flottants en machine.
|
||||
|
||||
import math
|
||||
|
||||
#I) Représentation des réels
|
||||
|
||||
#1) Quel mot code 25? et 25.0?
|
||||
#25 : 11001
|
||||
#en 64 bits: 0000000000000000000000000000000000000000000000000000000000011001
|
||||
#25. : 0,0*48,11001,1,000000100
|
||||
#en 64 bits: 010110000000000000000000000000000000000000000000000000000000100
|
||||
|
||||
#2)Quel mot code le plus grand réel positif normalisé? Quel réel représente-t-il? En donner un ordre de grandeur.
|
||||
#0111111111111111111111111111111111111111111111111111111111111111
|
||||
#Ordre de grandeur 2**1023
|
||||
|
||||
#3) Quel mot code le plus petit réel positif normalisé? Quel réel représente-t-il? En donner un ordre de grandeur.
|
||||
#0,0*53,1,0*10
|
||||
#0000000000000000000000000000000000000000000000000000010000000000
|
||||
#Ordre de grandeur 2**-1023
|
||||
|
||||
#4) Quel mot code le plus petit réel positif dénormalisé? Quel réel représente-t-il? En donner un ordre de grandeur.
|
||||
#0000000000000000000000000000000000000000000000000000000000000000
|
||||
#Représente zéro
|
||||
|
||||
#II) Provoquer l'erreur
|
||||
|
||||
#5)Donner un calcul dont le résultat produit un dépassement de capacité par valeurs inférieurs.
|
||||
#print(math.log(0.))
|
||||
#print(-1./2**1024)
|
||||
|
||||
#6) Donner un calcul dont le résultat produit -inf
|
||||
print(-2 * (2.**1023))
|
||||
|
||||
#7) Donner un calcul dont le résultat produit à tord 0.0
|
||||
print(2.**(-2**11))
|
||||
|
||||
#8) Donner un calcul dont le résultat ne produit pas à tord 0.0
|
||||
#print(1/10-math.log(math.exp(1/10)))
|
||||
print(1-(2.**-1023+1))
|
||||
|
||||
|
||||
#III) Comprendre les erreurs
|
||||
|
||||
#9) Quelle précision perd-on si on diviser un nombre à virgule flottante par deux puis qu'on le multiplie à nouveau par deux?
|
||||
#On perd une précision de 2**1022
|
||||
|
||||
#10) On considère le script Python suivant:
|
||||
def Algo10():
|
||||
x=1.0
|
||||
y=x+1.0
|
||||
|
||||
while y-x==1.0:
|
||||
x=x*2.0
|
||||
y=x+1.0
|
||||
Algo10()
|
||||
|
||||
#a)Ecrire l'algorithme correspondant à ce programme. Quel problème y a t'il?
|
||||
"""Algorithme:
|
||||
Donnees: Rien
|
||||
x <- 0
|
||||
y <- x+1
|
||||
TANT QUE y-x = 1:
|
||||
x <- x*2
|
||||
y <- x+1
|
||||
"""
|
||||
#Le problème est que cet algorithme est infini.
|
||||
|
||||
#b)Recopier ce programme dans un interpréterur et l'exécuter. Que constate-t-on? Quelle en est la raison?
|
||||
#On constate que cet algorithme se fini.
|
||||
|
||||
#c) Modifier ce programme afin d'introduire un compteur qui détermine le nombre d'itérations effectuées.
|
||||
def Algo10Iteration():
|
||||
x=1.0
|
||||
y=x+1.0
|
||||
i=0
|
||||
|
||||
while y-x==1.0:
|
||||
i+=1
|
||||
x=x*2.0
|
||||
y=x+1.0
|
||||
print(x)
|
||||
print(i)
|
||||
|
||||
Algo10Iteration()
|
||||
# On compte 53 itérations
|
||||
|
||||
#d) Interpréter précisément la différence de comportement entre l'algorithme et le programme
|
||||
#A la 53e itération l'erreur a été dépassée.
|
||||
|
||||
#e) Que se passerait-il si on initialisait x à 1 et y a x+1
|
||||
#Théoriquement: Le calcul continuerait jusqu'à atteindre le dépassement de capacité mémoire de l'ordinateur
|
||||
|
||||
#11) Affecter 2.0 **1023 à la variable a puis interpréter ce qu'affiche python pour chacun des calculs suivants:
|
||||
a=2.0**1023
|
||||
|
||||
#a) 2*a
|
||||
print(2*a)
|
||||
#Le dépassement de capacité en valeur négatif à été atteint donc le résultat est inf
|
||||
|
||||
#b) b=2*a puis b/2
|
||||
b=2*a
|
||||
print(b/2)
|
||||
#Comme le dépassement de capacité en valeur négatif à été atteint la valeur de b
|
||||
#correspond à l'infini et diviser l'infini par 2 donne toujours l'infini.
|
||||
|
||||
#c) 3*a-3*a
|
||||
print(3*a-3*a)
|
||||
#Comme le résultat de 3*a est considéré comme l'infini par python la différence des 2
|
||||
#correspond à une forme indéterminée, d'où le résultat.
|
||||
|
||||
#d) 1/(2*a)
|
||||
print(1/(2*a))
|
||||
#Comme le résultat de 2*a est considéré comme l'infini par python, lors du passage
|
||||
#à l'inverse python fait le quotient de 1 par l'infini ce qui lui donne 0.
|
||||
|
||||
#IV) Les nombres dénormalisés
|
||||
#12) On note x1 le plus petit réel positif normalisé représentable et x2 le plus
|
||||
#petit réel strictement supérieur à x1 normalisé représentable. Déterminer x1, x2
|
||||
#et (x2-x1)/(x1-0)
|
||||
#
|
||||
x1=2.**-1023
|
||||
print(x1)
|
||||
x2=2.**-1022
|
||||
print(x2)
|
||||
#(x2-x1)/(x1-0)=1
|
||||
print((x2-x1)/(x1-0))
|
||||
|
||||
#13)
|
||||
#y1=2**-1074
|
||||
y1=2.**-1074
|
||||
print(y1)
|
||||
#y2=2**-1073
|
||||
y2=2.**-1073
|
||||
print(y2)
|
||||
|
||||
print((y2-y1)/(x2-x1))
|
||||
#Ce résultat devrait valoir 2**-52 mais vaut 2**-51 à cause de l'erreur d'approximation lors de la division
|
||||
Binary file not shown.
@@ -1,260 +0,0 @@
|
||||
import inspect
|
||||
|
||||
|
||||
def test(arg1,arg2):
|
||||
a = arg1 + arg2
|
||||
return a
|
||||
|
||||
#do something with args
|
||||
|
||||
keywords=["assert","break","class","continue","def","del","elif","else","except","finally","for",
|
||||
"from","global","if","import","in","pass","print","raise","return","try","while","yield"]
|
||||
|
||||
conversion1 = {"assert":"ASSERT",
|
||||
"break":"SORTIR DE LA BOUCLE",
|
||||
"class":"CLASSE",
|
||||
"continue":"CONTINER",
|
||||
"def":"DONNEES",
|
||||
"del":"SUPPRIMER",
|
||||
"elif":["SINON SI","FAIRE"],
|
||||
"else":["SINON","FAIRE"],
|
||||
"except":"EXCEPTE",
|
||||
"finally":"FINALLEMENT",
|
||||
"for":["POUR","FAIRE"],
|
||||
"from":"DEPUIS",
|
||||
"global":"GLOBAL",
|
||||
"if":"SI",
|
||||
"import":"IMPORTER",
|
||||
"in":"DANS",
|
||||
"pass":"PASSER",
|
||||
"print":"AFFICHER",
|
||||
"raise":"RELEVER",
|
||||
"return":"AFFICHER",
|
||||
"try":"ESSAYER",
|
||||
"while":["TANT QUE","FAIRE"],
|
||||
"yield":"PASSER AU TOUR SUIVANT",
|
||||
"==":"=",
|
||||
"=":"<-"}
|
||||
|
||||
|
||||
|
||||
def algorithm(name):
|
||||
lines = inspect.getsource(name)
|
||||
print(lines)
|
||||
output = []
|
||||
lines = lines.split("\n")
|
||||
lines=removeUselessIndent(lines)
|
||||
lines=Converter(lines)
|
||||
for line in lines:
|
||||
output.append(Converter(line)())
|
||||
#print("output: ",output)
|
||||
return "\n".join(output)
|
||||
|
||||
|
||||
class Converter:
|
||||
def __init__(self,name):
|
||||
self.name=name
|
||||
self.code=inspect.getsource(name)
|
||||
print(self.code)
|
||||
self.lines=self.code.split("\n")
|
||||
self.indent_historic=[]
|
||||
self.indent=0
|
||||
self.cleanCode()
|
||||
|
||||
self.conversion= {"assert": [[None,"assert",None], [None,"ASSERT",None]],
|
||||
"break": [[None,"break"], [None,"SORTIR DE LA BOUCLE"]],
|
||||
"class": [["class",None], ["CLASS",None]],
|
||||
"continue": [[None,"continue",None], [None,"CONTINUER",None]],
|
||||
"def": [["def",None,"(",None,"):"], [None,":\nDONNES: ",None," :"]],
|
||||
"del": [[None,"del",None], [None,"SUPPRIMER",None]],
|
||||
"elif": [[None,"elif",None,":"], [None,"SINON SI",None," FAIRE"]],
|
||||
"else": [[None,"else:",None], [None,"SINON",None," FAIRE"]],
|
||||
"except": [[None,"except:",None], [None,"EXCEPTE",None]],
|
||||
"finally": [[None,"finally:",None], [None,"FINALLEMENT",None]],
|
||||
"for": [["for",None," in ",None,":"], ["POUR",None," DANS ",None," FAIRE"]],
|
||||
"from": [["from",None,"import",None], ["DEPUIS",None,"IMPORTER",None]],
|
||||
"global": [["global",None], ["GLOBAL",None]],
|
||||
"if": [[None,"if",None], [None,"SI",None]],
|
||||
"import": [[None,"import",None], [None,"IMPORTER",None]],
|
||||
" in ": [[None," in ",None], [None, "DANS ",None]],
|
||||
" is ": [[None," is ",None], [None," EST ",None]],
|
||||
"lambda": [[None,"lambda",None,":",None], [None,":\nDONNEES: ",None," :\nRENVOIE",None]],
|
||||
"pass": [[None,"pass"], [None,"PASSER",None]],
|
||||
"print": [[None,"print",None,"(",None,")"], [None,"AFFICHER: ",None,None]],
|
||||
"raise": [[None,"raise",None], [None,"RELEVER",None]],
|
||||
"return": [[None,"return",None], [None,"AFFICHER",None]],
|
||||
"try": [[None,"try:",None], [None,"ESSAYER",None]],
|
||||
"while": [["while ",None,":"], ["TANT QUE ",None," FAIRE"]],
|
||||
"yield": [[None,"yield"], [None,"PASSER AU TOUR SUIVANT"]],
|
||||
"True": [[None,"True",None], [None,"VRAI",None]],
|
||||
"False": [[None,"False",None], [None,"FAUX",None]],
|
||||
"==": [[None,"==",None], [None,"=",None]],
|
||||
"!=": [[None,"!=",None], [None,"≠",None]],
|
||||
"=": [[None,"=",None], [None," <- ",None]],
|
||||
"append": [[None,".append(",None,")"], ["AJOUTER A ",None," LA VALEUR ",None]],
|
||||
"not": [[None,"not",None], [None,"NON",None]]}
|
||||
|
||||
|
||||
def cleanCode(self):
|
||||
self.cleanIndents()
|
||||
|
||||
|
||||
def cleanIndents(self):
|
||||
self.line=self.lines[0]
|
||||
count=self.countIndent(self.line)
|
||||
for i in range(len(self.lines)):
|
||||
self.lines[i]=self.lines[i][4*count:]
|
||||
|
||||
def trackIndent(self,i):
|
||||
print(i)
|
||||
indent=self.countIndent(self.lines[i])
|
||||
if indent>len(self.indent_historic):
|
||||
self.addElementIndentHistoric(i)
|
||||
if indent<len(self.indent_historic):
|
||||
self.delElementIndentHistoric(i)
|
||||
print("i:",i)
|
||||
print("self.lines[i]:",self.lines[i])
|
||||
print("indent:",indent)
|
||||
print("historic:",self.indent_historic)
|
||||
print("")
|
||||
self.indent=indent
|
||||
self.removeIndent(i)
|
||||
|
||||
#self.indent_historic.append()
|
||||
|
||||
def addElementIndentHistoric(self,i):
|
||||
l={ " while ":" TANT QUE ",
|
||||
" for ": " POUR ",
|
||||
" if ": " SI "}
|
||||
for e in l:
|
||||
if e in self.lines[i]:
|
||||
self.indent_historic.append(l[e])
|
||||
print(self.lines[i])
|
||||
print(e)
|
||||
print(e in self.lines[i])
|
||||
|
||||
def delElementIndentHistoric(self,i):
|
||||
print(len(self.lines))
|
||||
print(i+1)
|
||||
self.lines[i]+="\n"+" "*4*(self.countIndent(self.lines[i+1])+1)+"FIN "+self.indent_historic[-1]
|
||||
del self.indent_historic[-1]
|
||||
|
||||
def countIndent(self,line):
|
||||
i=0
|
||||
for i in range(len(line)):
|
||||
if line[i]!=" ":
|
||||
break
|
||||
return int(i/4)
|
||||
|
||||
def removeIndent(self,i):
|
||||
count=self.countIndent(self.lines[i])
|
||||
self.line=self.line[count*4:]
|
||||
|
||||
def removeCommentaries(self):
|
||||
self.commentaries=""
|
||||
if "#" in self.line:
|
||||
i=self.next(self.line,"#")
|
||||
self.commentaries=self.line[i:]
|
||||
self.line=self.line[:i]
|
||||
if "\"\"\"" in self.line:
|
||||
i=self.next(self.line,"\"\"\"")
|
||||
self.commentaries=self.line[i:]
|
||||
self.line=self.line[:i]
|
||||
|
||||
def convert(self):
|
||||
breaking=False
|
||||
for key in self.conversion:
|
||||
if key=="==":
|
||||
breaking=True
|
||||
if key in self.line:
|
||||
self.apply(key)
|
||||
if breaking:
|
||||
break
|
||||
|
||||
def apply(self,key):
|
||||
#print("key:",key)
|
||||
l=self.missing(self.conversion[key][0])
|
||||
#print("l:",l)
|
||||
filled=self.fill(self.conversion[key][1],l)
|
||||
#print("filled:",filled)
|
||||
self.line="".join(filled)
|
||||
#print(self.line)
|
||||
|
||||
def missing(self,l):
|
||||
"""
|
||||
l= ["def ",None,"(",None,"):"]
|
||||
self.line= "def algorithm(name):"
|
||||
l1=["def","(","):"]
|
||||
"""
|
||||
line=[]
|
||||
if l[0]==None:
|
||||
i=self.next(self.line,l[1])
|
||||
line.append(self.line[:i])
|
||||
for i in range(1,len(l)-1):
|
||||
#print("missing loop:",l[i-1],l[i],l[i+1])
|
||||
if l[i]==None:
|
||||
a=self.between(self.line,l[i-1],l[i+1])
|
||||
line.append(a)
|
||||
#print("a",a)
|
||||
if l[-1]==None:
|
||||
i=self.next(self.line,l[-2])+len(l[-2])
|
||||
line.append(self.line[i:])
|
||||
return line
|
||||
|
||||
def removeNone(self,l):
|
||||
l1=[]
|
||||
for word in l:
|
||||
if word!=None:
|
||||
l1.append(word)
|
||||
return l1
|
||||
|
||||
def between(self,text,word1,word2):
|
||||
i1=self.next(text,word1)+len(word1)
|
||||
i2=i1+self.next(text[i1:],word2)
|
||||
return text[i1:i2]
|
||||
|
||||
def cut(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return [text[:i],word,text[i+len(word):]]
|
||||
|
||||
def next(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return i
|
||||
|
||||
def fill(self,l1,l2):
|
||||
line=[]
|
||||
for e1 in l1:
|
||||
if e1==None:
|
||||
line.append(l2[0])
|
||||
del l2[0]
|
||||
else:
|
||||
line.append(e1)
|
||||
return line
|
||||
|
||||
def assemble(self):
|
||||
pass
|
||||
|
||||
def __call__(self):
|
||||
for i in range(len(self.lines)):
|
||||
if i<len(self.lines)-1:
|
||||
self.trackIndent(i)
|
||||
self.indent=self.countIndent(self.lines[i])
|
||||
self.line=self.lines[i]
|
||||
self.removeCommentaries()
|
||||
self.convert()
|
||||
self.lines[i]= " "*4*self.indent+self.line+" "+self.commentaries
|
||||
self.cleanCode()
|
||||
|
||||
l1,l2=self.lines[0].split("\n")
|
||||
l1="ALGORITHME: "+l1.upper() +"\n\n"
|
||||
self.lines[0]=l1+l2
|
||||
return "\n".join(self.lines)
|
||||
|
||||
if __name__=="__main__":
|
||||
print(Converter(test)())
|
||||
#c=Converter("def test(arg1,arg2):")
|
||||
#print(c.between("def test(arg1,arg2):","(",")"))
|
||||
@@ -1,126 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Created on Mon Feb 11 16:23:27 2019
|
||||
|
||||
@author: hurc60248
|
||||
"""
|
||||
|
||||
"""
|
||||
I) Choisir le bon type de données
|
||||
1) a) Chaîne de caractère
|
||||
b) t uple
|
||||
c) chaîne de caractére
|
||||
d) chaîne de caractére
|
||||
|
||||
II)Prévoir ce que fait un script
|
||||
2) Ce script affichera un message d'erreur car t=(1,2,3) est un t uple et t+4 est une opération sur les entiers
|
||||
3) Ce script affichera "str"
|
||||
4) Ce script affichera "isepparis"
|
||||
5) Ce script affichera le crochet quand on demande a[0], et la virgule, quand on demande a[2]
|
||||
|
||||
III) Listes
|
||||
6)a) "randint(self, a, b) method of random.Random instance
|
||||
Return random integer in range [a, b], including both end points."
|
||||
|
||||
1er methode
|
||||
b) import random
|
||||
a=[]
|
||||
for i in range(50):
|
||||
a.append(random.randint(0,1))
|
||||
|
||||
2eme methode
|
||||
a=[random.randint(0,1) for i in range(50)]
|
||||
|
||||
7)a) Données : liste, element
|
||||
compteur <- 0
|
||||
Pour e dans liste FAIRE
|
||||
Si e=element FAIRE
|
||||
compteur <- compteur + 1
|
||||
Fin si
|
||||
Fin pour
|
||||
Afficher compteur
|
||||
FIN
|
||||
|
||||
b) def compter(liste, élément):
|
||||
compteur=0
|
||||
for e in liste:
|
||||
if e==element:
|
||||
compteur+=1
|
||||
return compteur
|
||||
|
||||
8)a) Données : liste, element
|
||||
sortie <- []
|
||||
pour i dans (0,longueur(liste)) faire
|
||||
si liste(i)=element FAIRE
|
||||
Ajouter a sortie l'indice i
|
||||
FIN si
|
||||
Afficher(sortie)
|
||||
FIN
|
||||
|
||||
b)def Compter(liste, element):
|
||||
sortie=[]
|
||||
for i in range(len(liste)):
|
||||
if liste[i]==element:
|
||||
sortie.append(i)
|
||||
return sortie
|
||||
|
||||
9)a)Données : liste
|
||||
somme=0
|
||||
Pour element dans liste FAIRE
|
||||
somme <- element + somme
|
||||
Fin pour
|
||||
moyenne=somme/longueur(liste)
|
||||
somme2=0
|
||||
Pour element dans liste FAIRE
|
||||
somme2 <- somme2 + (element-moyenne)²
|
||||
variance=somme2/longueur(liste)
|
||||
Afficher moyenne, variance
|
||||
FIN
|
||||
|
||||
b)def stats(liste):
|
||||
moyenne=sum(liste)/len(liste)
|
||||
variance=sum([(x-moyenne)**2 for x in liste])/len(liste)
|
||||
return (moyenne, variance)
|
||||
|
||||
10)a) Données : entnat1, entnat2
|
||||
Si entnat1 divise entnat2 FAIRE
|
||||
res <- vrai
|
||||
Sinon FAIRE
|
||||
res <-faux
|
||||
fin si
|
||||
Afficher resultat
|
||||
|
||||
b) Divise=lambda a,b:(b%a==0)
|
||||
|
||||
11)a) Données : entier
|
||||
liste=[]
|
||||
Pour element dans liste qui prend toutes les valeurs entre 1 et entier Faire
|
||||
Si element divise entier Faire
|
||||
Ajouter element dans liste
|
||||
fin si
|
||||
fin pour
|
||||
Afficher liste
|
||||
|
||||
b) ListeDiv=lambda a:[e for e in range(1,a+1) if Divise(e,a)]
|
||||
|
||||
12)a) Données : liste1, liste2
|
||||
commun=[]
|
||||
pour element dans liste1 faire
|
||||
Si element dans liste2 faire
|
||||
Ajouter element a commun
|
||||
fin si
|
||||
fin pour
|
||||
Afficher commun
|
||||
|
||||
b) ComListe=lambda a,b:list(set([e for e in a if e in b]))
|
||||
|
||||
13)a)
|
||||
|
||||
|
||||
PGCDN=lambda a,b:max(ComListe(ListDiv(a),ListDiv(b)))
|
||||
|
||||
|
||||
|
||||
|
||||
"""
|
||||
-308
@@ -1,308 +0,0 @@
|
||||
import inspect
|
||||
|
||||
|
||||
def test(arg1,arg2):
|
||||
a = arg1 + arg2
|
||||
return a
|
||||
|
||||
#do something with args
|
||||
|
||||
keywords=["assert","break","class","continue","def","del","elif","else","except","finally","for",
|
||||
"from","global","if","import","in","pass","print","raise","return","try","while","yield"]
|
||||
|
||||
conversion1 = {"assert":"ASSERT",
|
||||
"break":"SORTIR DE LA BOUCLE",
|
||||
"class":"CLASSE",
|
||||
"continue":"CONTINER",
|
||||
"def":"DONNEES",
|
||||
"del":"SUPPRIMER",
|
||||
"elif":["SINON SI","FAIRE"],
|
||||
"else":["SINON","FAIRE"],
|
||||
"except":"EXCEPTE",
|
||||
"finally":"FINALLEMENT",
|
||||
"for":["POUR","FAIRE"],
|
||||
"from":"DEPUIS",
|
||||
"global":"GLOBAL",
|
||||
"if":"SI",
|
||||
"import":"IMPORTER",
|
||||
"in":"DANS",
|
||||
"pass":"PASSER",
|
||||
"print":"AFFICHER",
|
||||
"raise":"RELEVER",
|
||||
"return":"AFFICHER",
|
||||
"try":"ESSAYER",
|
||||
"while":["TANT QUE","FAIRE"],
|
||||
"yield":"PASSER AU TOUR SUIVANT",
|
||||
"==":"=",
|
||||
"=":"<-"}
|
||||
|
||||
|
||||
|
||||
def algorithm(name):
|
||||
lines = inspect.getsource(name)
|
||||
print(lines)
|
||||
output = []
|
||||
lines = lines.split("\n")
|
||||
lines=removeUselessIndent(lines)
|
||||
lines=Converter(lines)
|
||||
for line in lines:
|
||||
output.append(Converter(line)())
|
||||
#print("output: ",output)
|
||||
return "\n".join(output)
|
||||
|
||||
|
||||
class Converter:
|
||||
def __init__(self,name):
|
||||
self.name=name
|
||||
self.code=inspect.getsource(name)
|
||||
print(self.code)
|
||||
self.lines=self.code.split("\n")
|
||||
self.indent_historic=[]
|
||||
self.indent=0
|
||||
self.cleanCode()
|
||||
|
||||
self.conversion= {"assert": [[None,"assert",None], [None,"ASSERT",None]],
|
||||
"break": [[None,"break"], [None,"SORTIR DE LA BOUCLE"]],
|
||||
"class": [["class",None], ["CLASS",None]],
|
||||
"continue": [[None,"continue",None], [None,"CONTINUER",None]],
|
||||
"def": [["def",None,"(",None,"):"], [None,":\nDONNES: ",None," :"]],
|
||||
"del": [[None,"del",None], [None,"SUPPRIMER",None]],
|
||||
"elif": [[None,"elif",None,":"], [None,"SINON SI",None," FAIRE"]],
|
||||
"else": [[None,"else:",None], [None,"SINON",None," FAIRE"]],
|
||||
"except": [[None,"except:",None], [None,"EXCEPTE",None]],
|
||||
"finally": [[None,"finally:",None], [None,"FINALLEMENT",None]],
|
||||
"for": [["for",None," in ",None,":"], ["POUR",None," DANS ",None," FAIRE"]],
|
||||
"from": [["from",None,"import",None], ["DEPUIS",None,"IMPORTER",None]],
|
||||
"global": [["global",None], ["GLOBAL",None]],
|
||||
"if": [[None,"if",None], [None,"SI",None]],
|
||||
"import": [[None,"import",None], [None,"IMPORTER",None]],
|
||||
" in ": [[None," in ",None], [None, "DANS ",None]],
|
||||
" is ": [[None," is ",None], [None," EST ",None]],
|
||||
"lambda": [[None,"lambda",None,":",None], [None,":\nDONNEES: ",None," :\nRENVOIE",None]],
|
||||
"pass": [[None,"pass"], [None,"PASSER",None]],
|
||||
"print": [[None,"print",None,"(",None,")"], [None,"AFFICHER: ",None,None]],
|
||||
"raise": [[None,"raise",None], [None,"RELEVER",None]],
|
||||
"return": [[None,"return",None], [None,"AFFICHER",None]],
|
||||
"try": [[None,"try:",None], [None,"ESSAYER",None]],
|
||||
"while": [["while ",None,":"], ["TANT QUE ",None," FAIRE"]],
|
||||
"yield": [[None,"yield"], [None,"PASSER AU TOUR SUIVANT"]],
|
||||
"True": [[None,"True",None], [None,"VRAI",None]],
|
||||
"False": [[None,"False",None], [None,"FAUX",None]],
|
||||
"==": [[None,"==",None], [None,"=",None]],
|
||||
"!=": [[None,"!=",None], [None,"≠",None]],
|
||||
"=": [[None,"=",None], [None," <- ",None]],
|
||||
"append": [[None,".append(",None,")"], ["AJOUTER A ",None," LA VALEUR ",None]],
|
||||
"not": [[None,"not",None], [None,"NON",None]]}
|
||||
|
||||
|
||||
def cleanCode(self):
|
||||
self.cleanIndents()
|
||||
|
||||
|
||||
def cleanIndents(self):
|
||||
self.line=self.lines[0]
|
||||
count=self.countIndent(self.line)
|
||||
for i in range(len(self.lines)):
|
||||
self.lines[i]=self.lines[i][4*count:]
|
||||
|
||||
def trackIndent(self,i):
|
||||
print(i)
|
||||
indent=self.countIndent(self.lines[i])
|
||||
if indent>len(self.indent_historic):
|
||||
self.addElementIndentHistoric(i)
|
||||
if indent<len(self.indent_historic):
|
||||
self.delElementIndentHistoric(i)
|
||||
print("i:",i)
|
||||
print("self.lines[i]:",self.lines[i])
|
||||
print("indent:",indent)
|
||||
print("historic:",self.indent_historic)
|
||||
print("")
|
||||
self.indent=indent
|
||||
self.removeIndent(i)
|
||||
|
||||
#self.indent_historic.append()
|
||||
|
||||
def addElementIndentHistoric(self,i):
|
||||
l={ " while ":" TANT QUE ",
|
||||
" for ": " POUR ",
|
||||
" if ": " SI "}
|
||||
for e in l:
|
||||
if e in self.lines[i]:
|
||||
self.indent_historic.append(l[e])
|
||||
print(self.lines[i])
|
||||
print(e)
|
||||
print(e in self.lines[i])
|
||||
|
||||
def delElementIndentHistoric(self,i):
|
||||
print(len(self.lines))
|
||||
print(i+1)
|
||||
self.lines[i]+="\n"+" "*4*(self.countIndent(self.lines[i+1])+1)+"FIN "+self.indent_historic[-1]
|
||||
del self.indent_historic[-1]
|
||||
|
||||
def countIndent(self,line):
|
||||
i=0
|
||||
for i in range(len(line)):
|
||||
if line[i]!=" ":
|
||||
break
|
||||
return int(i/4)
|
||||
|
||||
def removeIndent(self,i):
|
||||
count=self.countIndent(self.lines[i])
|
||||
self.line=self.line[count*4:]
|
||||
|
||||
def removeCommentaries(self):
|
||||
self.commentaries=""
|
||||
if "#" in self.line:
|
||||
i=self.next(self.line,"#")
|
||||
self.commentaries=self.line[i:]
|
||||
self.line=self.line[:i]
|
||||
if "\"\"\"" in self.line:
|
||||
i=self.next(self.line,"\"\"\"")
|
||||
self.commentaries=self.line[i:]
|
||||
self.line=self.line[:i]
|
||||
|
||||
def convert(self):
|
||||
breaking=False
|
||||
for key in self.conversion:
|
||||
if key=="==":
|
||||
breaking=True
|
||||
if key in self.line:
|
||||
self.apply(key)
|
||||
if breaking:
|
||||
break
|
||||
|
||||
def apply(self,key):
|
||||
#print("key:",key)
|
||||
l=self.missing(self.conversion[key][0])
|
||||
#print("l:",l)
|
||||
filled=self.fill(self.conversion[key][1],l)
|
||||
#print("filled:",filled)
|
||||
self.line="".join(filled)
|
||||
#print(self.line)
|
||||
|
||||
def missing(self,l):
|
||||
"""
|
||||
l= ["def ",None,"(",None,"):"]
|
||||
self.line= "def algorithm(name):"
|
||||
l1=["def","(","):"]
|
||||
"""
|
||||
line=[]
|
||||
if l[0]==None:
|
||||
i=self.next(self.line,l[1])
|
||||
line.append(self.line[:i])
|
||||
for i in range(1,len(l)-1):
|
||||
#print("missing loop:",l[i-1],l[i],l[i+1])
|
||||
if l[i]==None:
|
||||
a=self.between(self.line,l[i-1],l[i+1])
|
||||
line.append(a)
|
||||
#print("a",a)
|
||||
if l[-1]==None:
|
||||
i=self.next(self.line,l[-2])+len(l[-2])
|
||||
line.append(self.line[i:])
|
||||
return line
|
||||
|
||||
def removeNone(self,l):
|
||||
l1=[]
|
||||
for word in l:
|
||||
if word!=None:
|
||||
l1.append(word)
|
||||
return l1
|
||||
|
||||
def between(self,text,word1,word2):
|
||||
i1=self.next(text,word1)+len(word1)
|
||||
i2=i1+self.next(text[i1:],word2)
|
||||
return text[i1:i2]
|
||||
|
||||
def cut(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return [text[:i],word,text[i+len(word):]]
|
||||
|
||||
def next(self,text,word):
|
||||
for i in range(len(text)-len(word)+1):
|
||||
if text[i:i+len(word)]==word:
|
||||
break
|
||||
return i
|
||||
|
||||
def fill(self,l1,l2):
|
||||
line=[]
|
||||
for e1 in l1:
|
||||
if e1==None:
|
||||
line.append(l2[0])
|
||||
del l2[0]
|
||||
else:
|
||||
line.append(e1)
|
||||
return line
|
||||
|
||||
def assemble(self):
|
||||
pass
|
||||
|
||||
def __call__(self):
|
||||
for i in range(len(self.lines)):
|
||||
if i<len(self.lines)-1:
|
||||
self.trackIndent(i)
|
||||
self.indent=self.countIndent(self.lines[i])
|
||||
self.line=self.lines[i]
|
||||
self.removeCommentaries()
|
||||
self.convert()
|
||||
self.lines[i]= " "*4*self.indent+self.line+" "+self.commentaries
|
||||
self.cleanCode()
|
||||
|
||||
l1,l2=self.lines[0].split("\n")
|
||||
l1="ALGORITHME: "+l1.upper() +"\n\n"
|
||||
self.lines[0]=l1+l2
|
||||
return "\n".join(self.lines)
|
||||
|
||||
if __name__=="__main__":
|
||||
print(Converter(test)())
|
||||
#c=Converter("def test(arg1,arg2):")
|
||||
#print(c.between("def test(arg1,arg2):","(",")"))
|
||||
|
||||
|
||||
|
||||
from random import randint
|
||||
|
||||
#6b
|
||||
liste1=[]
|
||||
for i in range(50):
|
||||
liste1.append(randint(0,10))
|
||||
|
||||
|
||||
liste2=[randint(0,10) for i in range(50)]
|
||||
|
||||
#7b
|
||||
def Compter1(liste,valeur):
|
||||
compteur=0
|
||||
for element in liste:
|
||||
if element==valeur:
|
||||
compteur+=1
|
||||
return compteur
|
||||
|
||||
|
||||
Compter2=lambda liste,valeur:sum([element==valeur for element in liste])
|
||||
|
||||
#8b
|
||||
def Positionner(liste,valeur):
|
||||
positions=[]
|
||||
for i in range(liste):
|
||||
if liste[i]==valeur:
|
||||
positions.append(i)
|
||||
return positions
|
||||
|
||||
Positionner2=lambda liste,valeur:[n for n,element in enumerate(liste) if element==valeur]
|
||||
|
||||
def puissancede2(number):
|
||||
if number<2:
|
||||
return 0
|
||||
else:
|
||||
a=1
|
||||
while a*2<number:
|
||||
a*=2
|
||||
return a
|
||||
|
||||
#print(Converter(Positionner)())
|
||||
|
||||
|
||||
a=[1,2,3,5,1,3,5,4,4,2]
|
||||
print(puissancede2(4))
|
||||
@@ -1,14 +0,0 @@
|
||||
import math
|
||||
|
||||
def puissancede2(number):
|
||||
a=1
|
||||
while a*2<number:
|
||||
a*=2
|
||||
return a
|
||||
|
||||
print(puissancede2(513))
|
||||
|
||||
|
||||
puissance=lambda x:2**int(math.log(x)/math.log(2))
|
||||
|
||||
print(puissance(513))
|
||||
Binary file not shown.
@@ -9,8 +9,6 @@ import matplotlib.dates as mdates
|
||||
import sys
|
||||
print(sys.version)
|
||||
|
||||
|
||||
"""
|
||||
x=[1,2,3]
|
||||
y=[5,7,4]
|
||||
|
||||
@@ -92,7 +90,8 @@ plt.plot(x,y,label="loaded from file")
|
||||
x,y=np.loadtxt("text.txt",delimiter=",",unpack=True)
|
||||
|
||||
plt.plot(x,y,label="loaded from file")
|
||||
"""
|
||||
|
||||
#
|
||||
|
||||
def bytespdate2num(fmt,encoding="utf-8"):
|
||||
strconverter=mdates.strpdate2num(fmt)
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,22 @@
|
||||
class Employee:
|
||||
"""A sample Employee class"""
|
||||
|
||||
def __init__(self, first, last, pay):
|
||||
self.first = first
|
||||
self.last = last
|
||||
self.pay = pay
|
||||
|
||||
@property
|
||||
def email(self):
|
||||
return '{}.{}@email.com'.format(self.first, self.last)
|
||||
|
||||
@property
|
||||
def fullname(self):
|
||||
return '{} {}'.format(self.first, self.last)
|
||||
|
||||
def __repr__(self):
|
||||
return "Employee('{}','{}','{}')".format(self.first,self.last,self.pay)
|
||||
|
||||
#e=Employee("machin","truc",500)
|
||||
|
||||
#r=print(e.fullname)
|
||||
@@ -0,0 +1,53 @@
|
||||
import sqlite3
|
||||
from employee import Employee
|
||||
|
||||
#conn = sqlite3.connect('employee.db')
|
||||
conn = sqlite3.connect(':memory:')
|
||||
|
||||
|
||||
c = conn.cursor()
|
||||
|
||||
c.execute("""CREATE TABLE employees (
|
||||
first text,
|
||||
last text,
|
||||
pay integer
|
||||
)""")
|
||||
|
||||
|
||||
|
||||
def insert_emp(emp):
|
||||
with conn:
|
||||
c.execute(" INSERT INTO employees VALUES (?, ?, ?)", (emp.first,emp.last,emp.pay))
|
||||
|
||||
|
||||
def get_emps_by_name(lastname):
|
||||
c.execute("SELECT * FROM employees WHERE last=?", (lastname,))
|
||||
return c.fetchall()
|
||||
|
||||
def update_pay(emp, pay):
|
||||
with conn:
|
||||
c.execute("""UPDATE employees SET pay = :pay
|
||||
WHERE first = :first AND last = :last""",
|
||||
{'first': emp.first, 'last': emp.last, 'pay': pay})
|
||||
|
||||
def remove_emp(emp):
|
||||
with conn:
|
||||
c.execute("DELETE from employees WHERE first=:first AND last=:last",
|
||||
{'first':emp.first, 'last':emp.last})
|
||||
|
||||
|
||||
emp_1 = Employee('John', 'Doe', 8000)
|
||||
emp_2 = Employee('Jane', 'Doe', 9000)
|
||||
|
||||
insert_emp(emp_1)
|
||||
insert_emp(emp_2)
|
||||
|
||||
emps=get_emps_by_name('Doe')
|
||||
print(emps)
|
||||
|
||||
|
||||
update_pay(emp_1,500)
|
||||
print(emp_1)
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
-133
@@ -1,133 +0,0 @@
|
||||
#Hugues de Rubin de Cervens
|
||||
#Marc Partensky
|
||||
#Louise De Servigny
|
||||
|
||||
from scipy.optimize import bisect,newton
|
||||
|
||||
import math
|
||||
|
||||
f=lambda x:x**2-2
|
||||
#1)a) On définit f : x-->x^2-2. f s'annule en sqrt(2) et -sqrt(2). Or leurs valeurs décimales ne sont pas fini.
|
||||
"""b)DONNEES (a,b,e)
|
||||
x<-(a+b)/2
|
||||
TANT QUE abs(x^2-2)>e FAIRE:
|
||||
SI f(a)*f(b)>0: FAIRE:
|
||||
a<-x
|
||||
SINON FAIRE:
|
||||
b<-x
|
||||
x<-(a+b)/2
|
||||
FIN TANT QUE
|
||||
AFFICHER x
|
||||
"""
|
||||
|
||||
#c)
|
||||
def ZeroD(f,a,b,e):
|
||||
x=(a+b)/2
|
||||
while abs(f(x))>e:
|
||||
if f(a)*f(x)>0:
|
||||
a=x
|
||||
else:
|
||||
b=x
|
||||
x=(a+b)/2
|
||||
return x
|
||||
|
||||
#d)
|
||||
print("ZeroD:",ZeroD(f,1,2,e=10**(-12)))
|
||||
print(math.sqrt(2))
|
||||
|
||||
#2)a))
|
||||
print(bisect(f,1,2))
|
||||
#b)
|
||||
print("ZeroD:",ZeroD(f,1,2,e=10**(-12)))
|
||||
|
||||
#II) a)
|
||||
|
||||
|
||||
#b)Données(f,a,b,n)
|
||||
"""
|
||||
t : x-->(-f(a)*(b-a))/(f(b)-f(a))+a
|
||||
c=t(a,b)
|
||||
Pour i parcourant n
|
||||
c=t(a,b)
|
||||
Si f(a)f(c)>0
|
||||
a=c
|
||||
Sinon
|
||||
b=c
|
||||
Afficher c
|
||||
"""
|
||||
|
||||
#c)
|
||||
def ZeroL(f,a,b,n):
|
||||
t=lambda a,b:-f(a)*(b-a)/(f(b)-f(a))+a
|
||||
c=t(a,b)
|
||||
for i in range(n):
|
||||
c=t(a,b)
|
||||
if f(a)*f(c)>0:
|
||||
a=c
|
||||
else:
|
||||
b=c
|
||||
return c
|
||||
#d)
|
||||
print("ZeroL:",ZeroL(f,1,2,10))
|
||||
print(math.sqrt(2))
|
||||
|
||||
#e)
|
||||
def ZeroDC(f,a,b,e):
|
||||
x=(a+b)/2
|
||||
t=0
|
||||
while abs(f(x))>e:
|
||||
t+=1
|
||||
if f(a)*f(x)>0:
|
||||
a=x
|
||||
else:
|
||||
b=x
|
||||
x=(a+b)/2
|
||||
return (x,t)
|
||||
|
||||
#f)
|
||||
print("ZeroDC:",ZeroDC(f,1,2,10**(-12)))
|
||||
|
||||
#4)
|
||||
print(newton(f,1,maxiter=20))
|
||||
|
||||
|
||||
#III)
|
||||
#a) Figure...
|
||||
|
||||
#b) Algorithme
|
||||
"""Données(f,a,b,n)
|
||||
fp : a-->(f(a+h)-f(a))/h
|
||||
e=10^-10
|
||||
c=b
|
||||
Pour i parcourant n
|
||||
c=c-f(c)/fp(c,e)
|
||||
Si f(a)f(c)>0
|
||||
a=c
|
||||
SINON
|
||||
b=c
|
||||
Afficher c
|
||||
"""
|
||||
|
||||
#c)
|
||||
def ZeroN(f,a,b,n):
|
||||
fp=lambda a,h:(f(a+h)-f(a))/h
|
||||
e=10**(-10)
|
||||
c=b
|
||||
for i in range(n):
|
||||
c=c-f(c)/fp(c,e)
|
||||
if f(a)*f(c)>0:
|
||||
a=c
|
||||
else:
|
||||
b=c
|
||||
return c
|
||||
|
||||
#d)
|
||||
print("ZeroN:",ZeroN(f,1,2,20))
|
||||
print(math.sqrt(2))
|
||||
|
||||
#6)
|
||||
#a)
|
||||
print(newton(f,1,maxiter=20))
|
||||
|
||||
#b)
|
||||
print("ZeroN:",ZeroN(f,1,2,20))
|
||||
@@ -1,290 +0,0 @@
|
||||
"""
|
||||
Features:
|
||||
1:COMPLETED: print #renvoie str
|
||||
2:COMPLETED: addition #renvoie Polynomial
|
||||
3:COMPLETED: multiplication #renvoie Polynomial
|
||||
4:COMPLETED: derive #renvoie un Polynomial
|
||||
5:COMPLETED: division #renvoie couple de Polynomial
|
||||
6:COMPLETED: pgcd #renvoie Polynomial
|
||||
7: ppcm #renvoie Polynomial
|
||||
8: taylor #renvoie str ou liste "je sais pas encore"
|
||||
9: factoriser #renvoie str ou liste de liste des coefficients "pareil"
|
||||
10: racines reelles #renvoie liste des racines reelles
|
||||
11: racines complexes #renvoie liste des racines complexes
|
||||
12: Decomposition en éléments simples
|
||||
12: show #Affiche le polynome sur une fenetre pygame, pyglet ou matplotlib
|
||||
"""
|
||||
|
||||
from copy import deepcopy
|
||||
#import matplotlib.pyplot as plt #Old way to show the polynome on screen. Not very nice though...
|
||||
|
||||
from mygrapher.grapher import Grapher #Used to show the polynome on screen with the ability to move within it.
|
||||
|
||||
import random #Used only to generate random polynomes.
|
||||
|
||||
|
||||
class Polynomial:
|
||||
def __init__(self, coefficients):
|
||||
"""Create a polynomial using its coefficients."""
|
||||
self.coefficients = coefficients
|
||||
self.definition=[-10**20,10**20]
|
||||
def __repr__(self):
|
||||
"""Return the usual representation of a polynomial."""
|
||||
if self.coefficients==[]:
|
||||
return "0"
|
||||
liste = []
|
||||
if self.coefficients[0]!=0:
|
||||
liste.append(str(self.coefficients[0]))
|
||||
for degre,coefficient in enumerate(self.coefficients[1:],1):
|
||||
if coefficient!=0:
|
||||
liste.append(str(coefficient) + "X^" + str(degre))
|
||||
liste.reverse()
|
||||
text = "+".join(liste)
|
||||
text = text.replace("^1","").replace("+-","-").replace("1X","X")
|
||||
return text
|
||||
|
||||
def adapt(self,coefficients,size):
|
||||
"""Add zeros to the coefficients using coefficients and size."""
|
||||
coefficients += [0]*(size-len(coefficients))
|
||||
return coefficients
|
||||
|
||||
def __add__(self, other):
|
||||
"""Add 2 polynomials together by adding their coefficients."""
|
||||
maxdegree = max(self.degree()+1,other.degree()+1)
|
||||
cA = self.adapt(self.coefficients,maxdegree)
|
||||
cB = self.adapt(other.coefficients,maxdegree)
|
||||
newcoefficients = [a+b for (a,b) in zip(cA, cB)]
|
||||
A=Polynomial(newcoefficients)
|
||||
A.correct()
|
||||
return A
|
||||
|
||||
def __sub__(self, other):
|
||||
"""Substract 2 polynomials together by multiplying the second polynomial by -1 and adding it to the first using add method."""
|
||||
return self+other*Polynomial([-1])
|
||||
|
||||
def __mul__(self, other):
|
||||
"""Multiply 2 polynomials together using the formula for the coefficients."""
|
||||
degree = len(self.coefficients) + len(other.coefficients)
|
||||
A = self.coefficients + [0]*(degree-len(self.coefficients)+1)
|
||||
B = other.coefficients + [0]*(degree-len(other.coefficients)+1)
|
||||
newcoefficients = []
|
||||
for k in range(degree + 1):
|
||||
coeff = 0
|
||||
for i in range(k + 1):
|
||||
coeff += A[i] * B[k - i]
|
||||
newcoefficients.append(coeff)
|
||||
C = Polynomial(newcoefficients)
|
||||
C.correct()
|
||||
return C
|
||||
|
||||
def correct(self):
|
||||
"""Correct the coefficients of the polynomial by deleting useless zeros at the end,"""
|
||||
while len(self.coefficients)>1:
|
||||
if self.coefficients[-1] == 0:
|
||||
del self.coefficients[-1]
|
||||
else:
|
||||
break
|
||||
if self.coefficients==[0]:
|
||||
self.coefficients=[]
|
||||
"""and then replace float coefficients by int coefficients if possible."""
|
||||
for i in range(len(self.coefficients)):
|
||||
if self.coefficients[i]==int(self.coefficients[i]):
|
||||
self.coefficients[i]=int(self.coefficients[i])
|
||||
|
||||
def __len__(self):
|
||||
"""Return the number of coefficients.
|
||||
It is important to notice that it is not the degree due to the fact that
|
||||
the polynomial might have a degree of -inf and the len method must have positive values.
|
||||
In such a case this method will raise an error.
|
||||
It is why it is better to use the degree method in the general case."""
|
||||
A=deepcopy(self)
|
||||
A.correct()
|
||||
return len(A.coefficients)-1
|
||||
|
||||
def degree(self):
|
||||
"""Return the degree of a polynomial.
|
||||
It will return -1 if the degree is -inf to be computer friendly."""
|
||||
A=deepcopy(self)
|
||||
A.correct()
|
||||
return len(A.coefficients)-1
|
||||
|
||||
def __getitem__(self,index):
|
||||
"""Return a coefficient of the polynomial."""
|
||||
return self.coefficients[index]
|
||||
|
||||
def __setitem__(self,index,value):
|
||||
"""Change a coefficient of the polynomial."""
|
||||
self.coefficients[index] = value
|
||||
|
||||
def __delitem__(self,index):
|
||||
"""Delete a coefficient of the polynomial."""
|
||||
del self.coefficients[index]
|
||||
|
||||
def derivate(self):
|
||||
"""Derivate the polynomial."""
|
||||
self.coefficients = [i*c for (i,c) in enumerate(self.coefficients)]
|
||||
del self.coefficients[0]
|
||||
|
||||
def derivative(self):
|
||||
"""Return the derivative polynomial."""
|
||||
newcoefficients = [i*c for (i,c) in enumerate(self.coefficients)]
|
||||
del newcoefficients[0]
|
||||
return Polynomial(newcoefficients)
|
||||
|
||||
def unit(self):
|
||||
"""Return the polynomial unit form."""
|
||||
k=self.coefficients[-1]
|
||||
newcoefficients=[]
|
||||
for i in range(len(self.coefficients)):
|
||||
newcoefficients.append(self.coefficients[i]/k)
|
||||
A=Polynomial(newcoefficients)
|
||||
A.correct()
|
||||
return A
|
||||
|
||||
def unitarize(self):
|
||||
"""Convert the polynomial into its unit form."""
|
||||
self=self.unit()
|
||||
|
||||
def __xor__(self,other):
|
||||
"""Return the HCF (PGCD en francais) of self and other by Euclide algorithm. Make use of "^" operator."""
|
||||
R0 = deepcopy(self)
|
||||
R1 = deepcopy(other)
|
||||
R0.correct()
|
||||
R1.correct()
|
||||
listR=[R0,R1]
|
||||
while listR[-1].degree()>0:
|
||||
R,Q=listR[-2]/listR[-1]
|
||||
listR.append(R)
|
||||
return listR[-2]
|
||||
|
||||
#Resultat d'une enorme galere de 2h...
|
||||
#Algorithme d'Euclide:
|
||||
#a=b*q0+r0
|
||||
#b=r*q1+r1
|
||||
#r=r1*q2+r2
|
||||
#r1=r2*q3+r3
|
||||
#...
|
||||
#ri=r(i-1)*q(i-1)+1+0
|
||||
|
||||
def __or__(self,other):
|
||||
"""Return the LCM (PPCM en francais) using "i have absolutely no clue how to do this so figure it out!" Make use of "|" operator."""
|
||||
#On sent la (tres) grosse fatigue apres minuit.
|
||||
return "Figure it out!"
|
||||
|
||||
def __truediv__(self, other):
|
||||
"""Return the division of 2 polynomials."""
|
||||
R = deepcopy(self)
|
||||
B = deepcopy(other)
|
||||
R.correct()
|
||||
B.correct()
|
||||
Q = Polynomial([])
|
||||
while R.degree()>=B.degree():
|
||||
d = R.degree()-B.degree()+1
|
||||
C = Polynomial([0 for i in range(d)])
|
||||
C[-1] = R[-1]/B[-1]
|
||||
R = R-B*C
|
||||
Q = Q+C
|
||||
return [R,Q]
|
||||
|
||||
#Ce que j'ai du faire pour trouver l'implementation...
|
||||
#On a: A=BQ+R
|
||||
#[3,2,4,5,1]/[1,4,1]
|
||||
#[3,2,3,1,0]=[3,2,4,5,1]-[0,0,1]*[1,4,1] #[0,0,1,4,1]
|
||||
#[3,1,-1,0]=[3,2,3,1]-[0,1]*[1,4,1] #[0,1,4,1]
|
||||
#[4,5,0]=[3,1,-1]-[-1]*[1,4,1] #[-1,-4,-1]
|
||||
#[4,5]
|
||||
|
||||
#5=8*0+5 cas particulier de la division euclidienne
|
||||
|
||||
def __call__(self,x):
|
||||
"""Evaluate the polynomial given an x value."""
|
||||
sum=0
|
||||
for n,c in enumerate(self.coefficients):
|
||||
sum+=c*x**n
|
||||
return sum
|
||||
|
||||
def allDerivatives(self):
|
||||
"""Return the list of all derivatives of the polynome until the zero polynome."""
|
||||
B=deepcopy(self)
|
||||
derivatives=[deepcopy(self)]
|
||||
while B.degree()>1:
|
||||
B.derivate()
|
||||
derivatives.append(deepcopy(B))
|
||||
return derivatives
|
||||
|
||||
def roots(self):
|
||||
"""Return the list of all the roots of the polynomial."""
|
||||
"""Does that by finding where all the derivates cancel, to find new extrema and applying tvi."""
|
||||
roots=[]
|
||||
derivatives=self.allDerivatives()
|
||||
print(derivatives)
|
||||
derivatives.reverse()
|
||||
old_extrema=[]
|
||||
for derivative in derivatives:
|
||||
new_extrema=[]
|
||||
neglim=self.definition[0]
|
||||
poslim=self.definition[1]
|
||||
extrema=[neglim]+old_extrema+[poslim]
|
||||
for i in range(len(extrema)-1):
|
||||
if derivative(extrema[i])*derivative(extrema[i+1])<=0:
|
||||
new_extrema.append(derivative.TVI(extrema[i],extrema[i+1]))
|
||||
old_extrema=new_extrema[:]
|
||||
return new_extrema
|
||||
|
||||
|
||||
|
||||
def TVI(self,xa,xb,precision=10e-10):
|
||||
"""Return a float value x between a and b for which the polynomial canceled itself."""
|
||||
"""Does that based on theoreme of intermediate value with dichotomy."""
|
||||
if self(xa)*self(xb)>0:
|
||||
raise Exception("The polynomial cannot cancel itself within this interval.")
|
||||
a=min(xa,xb)
|
||||
b=max(xa,xb)
|
||||
x=(a+b)/2
|
||||
while abs(self(x))>precision:
|
||||
if self(x)*self(b)>0:
|
||||
b=x
|
||||
if self(x)*self(a)>0:
|
||||
a=x
|
||||
x=(a+b)/2
|
||||
return x
|
||||
|
||||
|
||||
def _floordiv__(self,other):
|
||||
"""Return a string of the decomposition in simple elements of the polynomial."""
|
||||
pass
|
||||
|
||||
def show(self):
|
||||
"""Show the polynomial with grapher."""
|
||||
Grapher([self])() #Instance Grapher only takes the list of the functions in parameter and can be called to display them.
|
||||
|
||||
def matplotlibShow(self,zone=[-5,5],precision=0.1):
|
||||
"""Show the polynomial with matplotlib using optional zone and precision."""
|
||||
z,Z=zone
|
||||
X=list([precision*x for x in range(int(z/precision),int(Z/precision))])
|
||||
Y=list([self(x) for x in X])
|
||||
plt.plot(X,Y,label="Polynomial")
|
||||
plt.show()
|
||||
|
||||
if __name__ == "__main__":
|
||||
#suite_random = [random.randint(0,10) for i in range(10)] #Create polynome as big as needed.
|
||||
#X=Polynomial(suite_random)
|
||||
suite1 = [3,2,4,5,1]
|
||||
suite2 = [1,4,1]
|
||||
suite3 = [4,5]
|
||||
A = Polynomial(suite1)
|
||||
B = Polynomial(suite2)
|
||||
C = Polynomial(suite3)
|
||||
print("A =",A)
|
||||
print("B =",B)
|
||||
print("C =",C)
|
||||
print("A+B =",A+B)
|
||||
print("A*B =",A*B)
|
||||
print("Derivative of A =",A.derivative())
|
||||
print("A/B :",A/B)
|
||||
print("Unit polynomial of C =",C.unit())
|
||||
print("HCF (PGCD en francais) of A and B (written A^B) =",A^B)
|
||||
print("LCM (PPCM en francais) of A and B (written A|B) =",A|B)
|
||||
print("Roots of A:",A.roots())
|
||||
print("Show A on screen:")
|
||||
A.show()
|
||||
@@ -0,0 +1,9 @@
|
||||
import math
|
||||
|
||||
N=200
|
||||
a1=sum([1-math.exp(1/n) for n in range(1,N)])
|
||||
a1b=sum([-1/n for n in range(1,N)])
|
||||
a2=sum([math.cosh(n)/math.cosh(2*n) for n in range(1,N)])
|
||||
a3=sum([math.factorial(n)/n**n for n in range(1,N)])
|
||||
|
||||
print(a1,a1b,a2,a3)
|
||||
@@ -1,3 +0,0 @@
|
||||
def f(a,b):
|
||||
if a==0: return b
|
||||
else: return (b+1)
|
||||
Reference in New Issue
Block a user