Initiation à la simulation numérique Introduction aux...

Initiation à la simulation numériqueIntroduction aux bases de données

Cours d’informatique de PSI

P.E LEROY

11 juin 2019

Cette œuvre est mise à disposition sous licenceAttribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé

Pour voir une copie de cette licence, visitezhttp://creativecommons.org/licenses/by-nc-sa/3.0/

ou écrivez àCreative Commons, PO Box 1866, Mountain View, CA 94042, USA.

http://creativecommons.org/licenses/by-nc-sa/3.0/

IPT 2e année Cours d’informatique

Table des matières

Avant-propos 3

Représentation des nombres en machine 4

Simulation numérique 6

Introduction 6Carte des cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Le tracé de courbes 8

Résolution d’une équation algébrique ou transcendante 11Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Méthode de la dichotomie (ou de la bissection) . . . . . . . . . . . . . . . . . . . . . . 12Méthode de Newton (ou de Newton-Raphson) . . . . . . . . . . . . . . . . . . . . . . . 14Applicabilité de ces méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Et en utilisant les bibliothèques de Python ? . . . . . . . . . . . . . . . . . . . . . . . . 17

Résolution d’un système inversible 19Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Méthode de Gauss (ou méthode d’élimination de Gauss-Jordan) . . . . . . . . . . . . . 20Et en utilisant les bibiothèques de Python ? . . . . . . . . . . . . . . . . . . . . . . . . 23

Résolution d’équations différentielles ordinaires 25Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Méthode d’Euler explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Et pour les ODE d’ordre 2 ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Et en utilisant les bibiothèques de Python ? . . . . . . . . . . . . . . . . . . . . . . . . 32

Intégration 35

Bases de données 38

Introduction 38Carte des cartes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

L’algèbre relationnelle : l’ADN de la gestion des BD 40

Premiers pas avec une BD 41

Interagir avec une BD 43

Recherches sélectives dans une BD 45

Bibliographie 46

– 2 – P.E LEROY


Avant-propos

Ce fascicule comporte une partie des cartes mentales présentées en cours d’informatique durant lepremier semestre de seconde année PSI.

Ce cours est une révision rapide des méthodes de base de la simulation numérique, ainsi que desnotions essentielles concernant les bases de données. L’analyse numérique et l’algèbre relationelle, quisous-tendent ces deux domaines de l’informatique, sont abordés ici très succintement. Le langage choisipour illustrer ces notions est le Python, dans sa version 3.

Les cartes mentales, utilisées comme support de pésentation, ont pour originalité de présenter lesnotions de manière éclatée, et non linéaire comme dans un cours classique. Elles permettent de relierefficacement les notions entre elles, et d’avoir en permanence une vue globale de l’ensemble des notionsabordées.

Elles s’utilisent donc comme des aides à la prise de note, permettant ainsi aisément de les compléteret de les agrémenter.

Ces cartes sont régulièrement mises à jour, complétées et corrigées, n’hésitez pas à me signaler touteerreur. Vous pouvez télécharger la dernière version sur mon blog http://psi-pel.blogspot.fr.

Je vous souhaite bon apprentissage !

Pierre-Emmanuel LEROYProfesseur de Physique et Informatique en PCSI

http://psi-pel.blogspot.fr

– 3 – P.E LEROY



– 4 –


1 # Numeration decimale (base 10)n=12450

3 n_d=’’while n!=0:

5 q=n//10 # Quotient de la division par 10r=n%10 # Reste de la division par 10

7 n_d=str(r)+n_d # Creation du nombre pour affichagen=q # n prend la valeur du quotient pour une nouvelle division par 10

9 print(’En numeration decimale :’,n_d)

11 # Numeration binaire (base 2)n=13

13 n_b=’’while n!=0:

15 q=n//2 # Quotient de la division par 2r=n%2 # reste de la division par 2

17 n_b=str(r)+n_b # Creation du nombre pour affichagen=q # n prend la valeur du quotient pour une nouvelle division par 2

19 print(’En numeration binaire :’,n_b)

../cartes_mentales/simulation_numerique/nombres.py

– 5 – P.E LEROY

– 6 –

– 7 –

– 8 –


1 import scipy as spimport matplotlib.pyplot as plt

3

# Premiere facon de creer une liste de valeurs5 #liste_x=sp.arange (1,4 ,0.1) # Va creer une liste de nombres entre 1 et 4 separes de

0.1

7 # Seconde facon de creer une liste de valeursliste_x=sp.linspace (1,4,40) # Va creer une liste de 40 nombres entre 1 et 4

9

# Creation de la liste des valeurs d’une fonction f(x)11 f=lambda x:x**2-4 # Va definir une fonction au sens mathematique

liste_fx=f(liste_x) # Va appliquer la fonction a chaque valeur de la liste ’liste_x ’13

# Representation graphique simple15 plt.plot(liste_x ,liste_fx)

plt.show()17

# Representation graphique plus elaboree , croix rouges avec les noms des axes et untitre

19 plt.plot(liste_x ,liste_fx ,’r+’)plt.title(’Representation de $f(x)=x^2-4$’) # Matplotlib comprend le LaTeX !

21 plt.xlabel(’$x$’)plt.ylabel(’$y$’)

23 plt.show()

25 # Creation de la liste des valeurs d’une fonction g(x)g=lambda x:x**2+4

27 liste_gx=g(liste_x)

29 # Representation graphique de f(x) et de g(x) sur le meme graphe avec titre etlegende

plt.plot(liste_x ,liste_fx ,’r+’,liste_x ,liste_gx)31 plt.title(’Representation de $f(x)$ et de $g(x)$’)

plt.xlabel(’$x$’)33 plt.ylabel(’$y$’)

plt.legend ((’$f(x)=x^2-4$’,’$g(x)=x^2+4$’))35 plt.show()

../cartes_mentales/simulation_numerique/trace_courbes.py

– 9 – P.E LEROY


– 10 – P.E LEROY

– 11 –

– 12 –


1 # Recherche par dichotomie du zero d’une fonction continue et monotone# f est la fonction

3 # a et b definissent l’intervalle de recherche# p definit la precision attendue pour le resultat

5

def recherche_dicho(f,a,b,p):7 if f(a)*f(b) >0:

return(’La fonction ne presente pas de solution dans l\’intervalle defini ’)9 while b-a>p:

if f(a)*f((a+b)/2) <0:11 b=(a+b)/2

else:13 a=(a+b)/2

return(a)15

f=lambda x:x**2-417 a=1

b=419 p=10**( -6)

21 print(recherche_dicho(f,a,b,p))

../cartes_mentales/simulation_numerique/equation_dichotomie.py

1 # Recherche par dichotomie du zero d’une fonction continue et monotone# f est la fonction

3 # a et b definissent l’intervalle de recherche# p definit la precision attendue pour le resultat

5

def recherche_dicho(f,a,b,p):7 if f(a)*f(b) >0:

return(’La fonction ne presente pas de solution dans l\’intervalle defini ’)9 while b-a>p:

if f((a+b)/2) ==0:11 return ((a+b)/2)

if f(a)*f((a+b)/2) <0:13 b=(a+b)/2

else:15 a=(a+b)/2

return(a)17

f=lambda x:x**2-419 a=1

b=321 p=10**( -6)

23 print(recherche_dicho(f,a,b,p))

../cartes_mentales/simulation_numerique/equation_dichotomie3.py


– 14 –


1 # Recherche par la methode de Newton du zero d’une fonction continue et monotone# f est la fonction , f’ sa derivee

3 # x0 est l’estimation de la solution# p definit la precision attendue pour le resultat

5

def recherche_newton(f,fp,x,p):7 while abs(f(x)/fp(x))>p:

if fp(x)==0:9 return(’La derivee de la fonction s\’annule entre l\’estimation et la solution ’

)x=x-f(x)/fp(x)

11 return(x)

13 f=lambda x:x**2-4fp=lambda x:2*x

15 x=1 # Estimation de la valeur de la solutionp=10**( -6)

17

print(recherche_newton(f,fp ,x,p))

../cartes_mentales/simulation_numerique/equation_newton.py


– 16 –

– 17 –


# Zeros d’une fonction2

import scipy.optimize as op4 f=lambda x:x**2-4

print(op.bisect(f,1,4,xtol =10**( -6)))6

import scipy.optimize as op8 f=lambda x:x**2-4fp=lambda x:2*x

10 print(op.newton(f,1,fp,tol =10**( -6)))

12 import scipy as spp=sp.poly1d ([1,0,-4])

14 print(sp.roots(p))

16 #from sympy.solvers import solve#from sympy import Symbol

18 #x=Symbol(’x ’)#solve(x**2-4,x)

../cartes_mentales/simulation_numerique/equation_bibliotheques_python.py


– 19 –

– 20 –


1 # Programme permettant la resolution d’un systeme lineaire a.x=b par la# methode de Gauss (ou methode d’elimination de Gauss -Jordan)

3

import scipy as sp5

a=sp.array ([[1,5,6],[2,5,6],[4,6,7]], float)7 b=sp.array ([[2] ,[5] ,[7]] , float)x=sp.array ([[0] ,[0] ,[0]] , float)

9

n=len(a)11

for k in range(n): # Parcours des lignes13 akk=a[k,k] # Valeur du pivot de la ligne k

for j in range(n): # Mise a la valeur 1 du pivot de la ligne k (incidence sur laligne entiere)

15 a[k,j]=a[k,j]/akkb[k,0]=b[k,0]/ akk # Repercussion sur la matrice b

17

for i in range(k+1,n): # Parcours des lignes19 aik=a[i,k] # Valeur du coefficient de la ligne i

for j in range(n): # Elimination du coefficient sous -pivot de la ligne i21 a[i,j]=a[i,j]-aik*a[k,j]

b[i,0]=b[i,0]-aik*b[k,0] # Repercussion sur la matrice b23

x[n-1,0]=b[n-1,0] # Calcul des solutions , la premiere correspond a la derniere lignede la matrice b

25 for k in range(n-1):x[n-2-k,0]=b[n-2-k,0]

27 for i in range(k+1):x[n-2-k,0]=x[n-2-k,0]-a[n-2-k,n-1-i]*x[n-1-i,0]

29

print("Solutions trouvees :")31 print(x)

../cartes_mentales/simulation_numerique/systeme_lineaire_gauss.py



1 # Programme permettant la resolution d’un systeme lineaire a.x=b par la# methode de Gauss (ou methode d’elimination de Gauss -Jordan)

3

import scipy as sp5

a=sp.array ([[1,5,6],[2,5,6],[4,6,7]], float)7 b=sp.array ([[2] ,[5] ,[7]] , float)x=sp.array ([[0] ,[0] ,[0]] , float)

9

n=len(a) # Dimension de la matrice (nombre de lignes)11

def permutation_lignes(i,k): # Fonction permettant la permutation de deux lignes13 for j in range(n):

a[i,j],a[k,j]=a[k,j],a[i,j]15 b[i,0],b[k,0]=b[k,0],b[i,0]

17 def zeros_sous_pivot(k): # Fonction permettant de faire apparaitre des zeros sous lepivotakk=a[k,k]

19 for j in range(n):a[k,j]=a[k,j]/akk

21 b[k,0]=b[k,0]/ akkfor i in range(k+1,n):

23 aik=a[i,k]for j in range(n):

25 a[i,j]=a[i,j]-aik*a[k,j]b[i,0]=b[i,0]-aik*b[k,0]

27

def calcul_solutions (): # Fonction permettant le calcul des solutions29 x[n-1,0]=b[n-1,0]

for k in range(n-1):31 x[n-2-k,0]=b[n-2-k,0]

for i in range(k+1):33 x[n-2-k,0]=x[n-2-k,0]-a[n-2-k,n-1-i]*x[n-1-i,0]

35 def recherche_pivot(k):for i in range(k+1,n):

37 if a[i,k]!=0:return(i,True)

39 return(i,False) # Retourner i ne sert ici a rien , puisqu ’aucun pivot n’a etetrouve

41 def triangularisation (): # Fonction permettant de transformer la matrice en matricetriangulaire superieurefor k in range(n):

43 if a[k,k]==0:ligne_pivot ,trouve_pivot=recherche_pivot(k)

45 if trouve_pivot ==True:permutation_lignes(ligne_pivot ,k)

47 else:return(False)

49 zeros_sous_pivot(k)return(True)

51

53 res_triang=triangularisation ()if res_triang ==True:

55 print("Solutions trouvees :")calcul_solutions ()

57 print(x)else:

59 print("Systeme sans solutions !")

../cartes_mentales/simulation_numerique/systeme_lineaire_gauss5.py


– 23 –


1 # Resolution d’un systeme lineaire inversibleimport scipy.linalg as spl

3 import scipy as sp

5 A=sp.array ([[1,5,6],[2,5,6],[4,6,7]])b=sp.array ([[2] ,[5] ,[7]])

7 x=spl.solve(A,b)print(x)

9 print(A.dot(spl.solve(A,b))-b) # Pour voir la precision de la methode ...

11 x2=spl.inv(A).dot(b)print(x2)

13 print(A.dot(spl.inv(A).dot(b))-b) # Pour comparer la precision de la methode ...

15 #import sympy as sp#A=sp.Matrix ([[1,5,6],[2,5,6],[4 ,6,7]])

17 #b=sp.Matrix ([[2] ,[5] ,[7]])#print(A.LUsolve(b))

19 #print(A*A.LUsolve(b)-b) # Pour comparer la precision de la methode ...

../cartes_mentales/simulation_numerique/systeme_lineaire_bibliotheques_python.py


– 25 –

– 26 –


1 # Resolution d’une equation differentielle du premier ordre de la forme du/dt=f(u)# u est la fonction solution de l’equation differentielle

3 # f est la fonction qui designe le second membre# N designe le nombre d’iteration de la methode

5 # p designe le pas de discretisation de la methode (equivaut a dt)# duree=N*p designe la duree sur laquelle on modelise le phenomene

7

# Une variante sera donnee par la suite ...9

import scipy as sp11 import matplotlib.pyplot as plt

import time13

def euler_explicite(f,u0,p,N):15 u=[u0] # La liste u va contenir les valeurs de la fonction solution u(t)

for k in range(N):17 u.append(u[k]+p*f(u[k]))

return(u)19

f=lambda u:-1/tau*u21 tau=2

u0=1023 p=10**( -1) # equivaut a dt

duree =7* tau25 N=int(duree/p)

27 debut=time.time()liste_t=sp.linspace(0,duree ,N+1) # Il y a eu N iterations plus la valeur initiale ,

soit N+1 valeurs29 liste_u=euler_explicite(f,u0,p,N)

fin=time.time()31

print(’Methode terminee en’,fin -debut ,’s’,’, liste de dimension ’,len(liste_u))33

liste_ta=sp.linspace(0,duree ,300)35 liste_ua=u0*sp.exp(-liste_ta/tau)

37 plt.plot(liste_t ,liste_u ,liste_ta ,liste_ua)plt.xlabel(’$t$’)

39 plt.ylabel(’$u(t)$’)plt.title(’Representation de $u(t)$’)

41 plt.legend ((’$u_{Euler}(t)$’,’$u_{Analytique }(t)$’))plt.show()

../cartes_mentales/simulation_numerique/equadiff_euler_explicite.py



p = 10−1 et ∆t = 7τ

p = 100 et ∆t = 7τ

p = 100,5 ' 3, 16 et ∆t = 7τ


– 29 –


# Resolution d’equations differentielles (ODE) par la methode d’euler2

# Importation des bibiotheques4 import matplotlib.pyplot as plt # Bibiotheque graphique (pour le trace des courbes)

import scipy as sp # Bibiotheque scientifique6

# Exemple d’une ODE d’ordre 1 de la forme du/dt+1/ tau*u=0 (remplacer 0 par le secondmembre constant si besoin)

8 # On a donc (a l’ordre 1) u(t+dt)=u(t)+dt*(-1/tau*u(t) -0)def euler_1o(u0 ,tau ,N,dt):

10 u=[u0] # Creation d’une liste (locale) u avec la valeur initiale de u(t=0)for n in range(N):

12 u.append(u[n]+dt*(-1/tau*u[n]-0)) # On ajoute a la liste u la valeur de u[n+1] calculee a partir de u[n]return(u) # On renvoit la liste u

14

tau=5 # Constante de temps tau16 u0=10 # Valeur de u(t=0)

duree =7* tau # Duree sur laquelle u(t) sera calculee18 dt=10**( -3) # Pas (equivaut a p)

N=int(duree/dt) # Nombre de points20

liste_u=euler_1o(u0 ,tau ,N,dt) # La liste (globale) u prend les valeurs de u(t)calculees par la methode d’euler

22 liste_t=sp.linspace(0,duree ,N+1) # La liste t prend les N+1 valeurs de t (N valeurscalculees plus la valeur initiale)

24 plt.plot(liste_t ,liste_u) # Trace de u(t)plt.xlabel(’$t$’)


28 plt.show() # Affichage du graphe

30

# Exemple d’une ODE d’ordre 2 de la forme d^2u/dt^2+w0/Q*du/dt+w0^2*u=032 # On pose U=du/dt

# On a donc (a l’ordre 1) :34 # u(t+dt)=u(t)+dt*U

# et U(t+dt)=U(t)+dt*(-w0/Q*U(t)-w0^2*u(t) -0)36 def euler_2o(u0 ,U0 ,w0 ,Q,N,dt):

u=[u0]38 U=[U0]

for n in range(N):40 u.append(u[n]+dt*U[n])

U.append(U[n]+dt*(-w0/Q*U[n]-w0**2*u[n]-0))42 return(u)

44 u0=0 # Valeur de u(t=0)U0=2 # Valeur de du/dt(t=0)

46 f0=2 # Frequence propre des oscillationsw0=2*sp.pi*f0 # Pulsation propre

48 Q=5 # Facteur de qualiteduree =5*1/f0 # Duree sur laquelle u(t) sera calculee

50 dt=10**( -3) # Pas (equivaut a p)N=int(duree/dt) # Nombre de points

52

liste_u=euler_2o(u0 ,U0 ,w0,Q,N,dt)54 liste_t=sp.linspace(0,duree ,N+1)

56 plt.plot(liste_t ,liste_u)plt.xlabel(’$t$’)


60 plt.show()

../cartes_mentales/simulation_numerique/equadiff_euler_1o_2o.py


– 32 –


# Resolution d’equations differentielles2

# 1. Du premier ordre de la forme du/dt = f(u)4 import scipy as spfrom scipy.integrate import odeint

6 import matplotlib.pyplot as plt

8 def f(u,t,tau): # On ajoute l’argument ’t’ car f(u) peut contenir cette variable""" Definit le membre de droite de l’equation du/dt=f(u)"""

10 return (-1/tau*u)

12 tau=2u0=10

14 p=10**( -1)duree =7* tau

16 N=int(duree/p)

18 t=sp.linspace(0,duree ,N)u=odeint(f,u0,t,args=(tau ,)) # Les arguments a passer a la fonction ’fun(u,t,...) ’

doivent etre regroupes dans un tuple20

plt.plot(t,u[: ,0]) # Il faut extraire la premiere colonne de la matrice solution (cf.2.)

22 plt.xlabel(’$t$’)plt.ylabel(’$u(t)$’)

24 plt.title(’Representation de $u(t)$’)plt.show()

26

# 2. Du second ordre de la forme d^2u/dt+w0/Q*du/dt+w0^2*u=028 import scipy as sp

from scipy.integrate import odeint30 import matplotlib.pyplot as plt

32 def f(U,t,w0,Q):""" Definit le membre de droite de l’equation dU/dt=f(U)"""

34 return([-w0/Q*U[0]-w0**2*U[1],U[0]])

36 w0=1Q=10

38 U0=[0 ,10]p=10**( -1)

40 duree =5*2*sp.pi/w0N=int(duree/p)

42

t=sp.linspace(0,duree ,N)44 U=odeint(f,U0,t,args=(w0 ,Q))

46 plt.plot(t,U[: ,1]) # Il faut extraire la seconde colonne de la matrice solution quicontient les valeurs de u(t)

plt.xlabel(’$t$’)48 plt.ylabel(’$u(t)$’)

plt.title(’Representation de $u(t)$’)50 plt.show()

52 #from sympy import dsolve ,Derivative ,Function#from sympy.abc import t,tau

54 #u=Function(’u ’)#dsolve(Derivative(u(t),t)+1/ tau*u(t),u(t))

../cartes_mentales/simulation_numerique/equadiff_bibliotheques_python.py


– 35 –


1 # Integration d’une fonction definie par une suite de valeursimport scipy as sp

3

dx =0.0015 f=lambda x:x**2-4 # Expression de f(x)

liste_x=sp.arange(0,4,dx) # ’arange ’ est plus adapte pour imposer un pas7 liste_fx=f(liste_x)

9 # Methode des rectangles a gauchedef integration_rg(liste_fx):

11 res=0for i in range(len(liste_fx) -1): # Derniere valeur non prise en compte

13 res=res+liste_fx[i]*dxreturn(res)

15

print(integration_rg(liste_fx))17

# Methode des rectangles a droite19 def integration_rd(liste_fx):

res=021 for i in range(1,len(liste_fx)): # Premiere valeur non prise en compte

res=res+liste_fx[i]*dx23 return(res)

25 print(integration_rd(liste_fx))

27 # Methode des points milieux , ne peut s’appliquer qu’a des fonctions d’expressionconnue

def integration_pm(liste_x ,f):29 res=0

for i in range(len(liste_fx) -1): # Derniere valeur non prise en compte31 res=res+f(liste_x[i]+dx/2)*dx

return(res)33

print(integration_pm(liste_x ,f))35

# Methode des trapezes37 def integration_t(liste_fx):

res=039 for i in range(len(liste_fx) -1): # Derniere valeur non prise en compte

res=res+liste_fx[i]*dx+( liste_fx[i+1]- liste_fx[i])*dx/241 return(res)

43 print(integration_t(liste_fx))

../cartes_mentales/simulation_numerique/integration.py



1 # Integration d’une fonctionimport scipy.integrate as spi

3 import scipy as sp

5 f=lambda x:x**2-4print(spi.quad(f,0,4)) # Retourne un tuple forme de l’estimation de l’integrale et de

son erreur7

liste_x=sp.linspace (0,4,50)9 liste_fx=f(liste_x)

print(spi.trapz(liste_fx ,liste_x))11

#import sympy as sp13 #x=sp.Symbol(’x ’)

#sp.integrate(x**2-4,(x,0,4))

../cartes_mentales/simulation_numerique/integration_bibliotheques_python.py


– 38 –

– 39 –

– 40 –

– 41 –


# Creation d’une BD2

import sqlite34

bd="/home/pe/pe/info/spe/cours/cartes_mentales/simulation_numerique/bd_creation.sq3"# Indication du chemin du fichier correspondant a la BD

6 connexion=sqlite3.connect(bd) # Connexion a la BDcurseur=connexion.cursor () # Creation d’un curseur (tampon memoire)

8

curseur.execute("CREATE TABLE membres(age INTEGER ,nom TEXT ,taille REAL)") # Le choixdes majuscules est arbitraire

10

curseur.execute("INSERT INTO membres(age ,nom ,taille) VALUES(21,’Dupont ’,1.83)")12 curseur.execute("INSERT INTO membres(age ,nom ,taille) VALUES(21,’Martin ’,1.73)")

curseur.execute("INSERT INTO membres(age ,nom ,taille) VALUES(21,’ Richard ’,1.69)")14

connexion.commit () # Transfert des enregistrements vers la BD16

curseur.close() # Fermeture du curseur18 connexion.close () # Fermeture de la connexion

../cartes_mentales/simulation_numerique/bd_premiers_pas.py


– 43 –


# Interactions avec une BD2 import sqlite3

4 bd="/home/pe/pe/info/spe/cours/cartes_mentales/simulation_numerique/bd_creation.sq3"# Indication du chemin du fichier correspondant a la BD

connexion=sqlite3.connect(bd) # Connexion a la BD6 curseur=connexion.cursor () # Creation d’un curseur (tampon memoire)

8 curseur.execute("SELECT * FROM membres") # Selection de toute la table ’membres ’for t in curseur: # Pour afficher le contenu du curseur

10 print(t)

12 curseur.execute("SELECT * FROM membres")print(list(curseur)) # Autre facon ...

14

curseur.execute("SELECT * FROM membres")16 print(tuple(curseur)) # Autre facon ...

18 curseur.execute("SELECT * FROM membres")print(curseur.fetchall ()) # Autre facon ...

20

data =[(17 ,"Durand" ,1.74) ,(22,"Berger" ,1.71) ,(20,"Guyonvarch" ,1.65)] # Insertion dedonnees a l’aide d’une boucle

22 for t in data:curseur.execute("INSERT INTO membres(age ,nom ,taille) VALUES (?,?,?)",t)

24 connexion.commit () # Transfert des enregistrements vers la BDcurseur.execute("SELECT * FROM membres") # Pour voir le resultat ...

26 for t in curseur:print(t)

28

curseur.execute("SELECT * FROM membres")30 curseur.execute("UPDATE membres SET nom=’Bergere ’ WHERE nom=’Berger ’") # Mise a jour

d’un enregistrementcurseur.execute("DELETE from membres WHERE nom=’Durand ’") # Suppression d’un

enregistrement32 curseur.execute("DELETE from membres WHERE nom=’Bergere ’") # Suppression d’un

enregistrementcurseur.execute("DELETE from membres WHERE nom=’Guyonvarch ’") # Suppression d’un

enregistrement34 connexion.commit () # Transfert des enregistrements vers la BD

curseur.execute("SELECT * FROM membres") # Pour voir le resultat ...36 for t in curseur:

print(t)38

curseur.close() # Fermeture du curseur40 connexion.close () # Fermeture de la connexion

../cartes_mentales/simulation_numerique/bd_interagir.py


– 45 –


Références

[1] Faccanoni, Gloria, Analyse numérique, http://faccanoni.univ-tln.fr/user/enseignements/2012_2013_M33_L2.pdf

[2] Dudok de Wit, Thierry, Analyse numérique, http://lpc2e.cnrs-orleans.fr/~ddwit/enseignement/cours_analnum.pdf

[3] Viot, Pascal, Méthodes d’analyse numérique, http://www.lptmc.jussieu.fr/user/viot/COURS/numeri.pdf

[4] Swinnen, Gérard, Apprendre à programmer avec Python 3, Eyrolles, 2012.

[5] Numpy and Scipy documentation, http://docs.scipy.org/doc/

[6] Matplotlib, http://matplotlib.org/

[7] Sympy documentation, http://docs.sympy.org/0.7.2/index.html


http://faccanoni.univ-tln.fr/user/enseignements/2012_2013_M33_L2.pdf

http://faccanoni.univ-tln.fr/user/enseignements/2012_2013_M33_L2.pdf

http://lpc2e.cnrs-orleans.fr/~ddwit/enseignement/cours_analnum.pdf

http://lpc2e.cnrs-orleans.fr/~ddwit/enseignement/cours_analnum.pdf

http://www.lptmc.jussieu.fr/user/viot/COURS/numeri.pdf

http://www.lptmc.jussieu.fr/user/viot/COURS/numeri.pdf

http://docs.scipy.org/doc/

http://matplotlib.org/

http://docs.sympy.org/0.7.2/index.html

Initiation à la simulation numérique Introduction aux...

Documents

Transcript of Initiation à la simulation numérique Introduction aux...