[4TPY303U] TD1

Le mode "console"

Opérations de base

entiers

In [1]:
5+4
Out[1]:
9
In [2]:
5-14
Out[2]:
-9
In [3]:
3*8
Out[3]:
24

réels

In [4]:
3.5*3.14
Out[4]:
10.99

$e \times \hbar$

In [5]:
1.6e-19*6.6e-34
Out[5]:
1.056e-52

complexes

In [6]:
(1+3j)*(3+2j)
Out[6]:
(-3+11j)
In [7]:
(1+3j)/(3+2j)
Out[7]:
(0.6923076923076924+0.5384615384615385j)

Problème de la division (seulement en python 2.x)

In [8]:
2/3
Out[8]:
0.6666666666666666
In [9]:
2./3
Out[9]:
0.6666666666666666
In [10]:
from __future__ import division
In [11]:
2/3
Out[11]:
0.6666666666666666

Affectation des variables

$x = a + j b^2$

In [12]:
a = 3
b = 6.5
x = a + 1j*(b**2)
print(x)

(3+42.25j)
In [13]:
type(a), type(b), type(x)
Out[13]:
(int, float, complex)

Les bibliothèques

In [14]:
import scipy
scipy.sin(0.1)
Out[14]:
0.099833416646828155
In [15]:
import scipy as sp
sp.sin(0.1)
Out[15]:
0.099833416646828155
In [16]:
from scipy import sin
sin(0.1)
Out[16]:
0.099833416646828155
In [17]:
from scipy import *
sin(0.1), cos(2), log(4)
Out[17]:
(0.099833416646828155, -0.41614683654714241, 1.3862943611198906)

Listes et tableaux

Listes

In [18]:
L1 = [1,20,3.14,1+3j]
L2 = [2.5,"toto", L1]
In [19]:
print(L1,L2)

[1, 20, 3.14, (1+3j)] [2.5, 'toto', [1, 20, 3.14, (1+3j)]]
In [20]:
type(L1), type(L2)
Out[20]:
(list, list)

Tableau (array)

In [21]:
from numpy import * # les tableaux appartiennent au module numpy
A = array([1,4,3.14])
L = [5,pi/2]
B = array(L)
print (A,L,B)

[ 1.    4.    3.14] [5, 1.5707963267948966] [ 5.          1.57079633]
In [22]:
type(A),type(L),type(B)
Out[22]:
(numpy.ndarray, list, numpy.ndarray)

Différences

In [23]:
L1 = [3,6,2]
L2 = [8,14,4]
L = L1+L2
print (L)

[3, 6, 2, 8, 14, 4]
In [24]:
A1 = array(L1)
A2 = array(L2)
A = A1+A2
print (A)

[11 20  6]

fonction range()

In [25]:
L = range(4,15,3)
print (L)

range(4, 15, 3)

Petite subtilité en Python 3.x la fonction range ne retourne pas une liste comme en Python 2.x mais un objet de type range. Pour afficher la liste associée à un objet de type range il faut rendre la liste explicite.

In [26]:
print (list(L))

[4, 7, 10, 13]

Le comportement d'un objet de type range est en revanche similaire à celui d'un objet liste.

fonctions arange() et linspace()

Ces deux fonctions appartiennent au module numpy, elle ne retourne pas des listes mais des tableaux (array).

In [27]:
A1 = arange(2,3,0.2)
print (A1)

[ 2.   2.2  2.4  2.6  2.8]
In [28]:
A2 = linspace(0,10,6)
print (A2)

[  0.   2.   4.   6.   8.  10.]

affichage des éléments d'un tableau 1D

Afficher tout le tableau

In [29]:
x = linspace(2,12,6) 
print (x)

[  2.   4.   6.   8.  10.  12.]

N'afficher que certaines valeurs dont l'indice est connu

In [30]:
print (x[0], x[3])

2.0 8.0

Afficher l'ensemble des éléments à partir d'un indice donné

In [31]:
print(x[3:])

[  8.  10.  12.]

Afficher l'ensemble des éléments jusqu'à un indice donné

In [32]:
print (x[:3])

[ 2.  4.  6.]

Un autre façon d'afficher tout le tableau

In [33]:
print (x[:])

[  2.   4.   6.   8.  10.  12.]

Afficher depuis la fin du tableau (python est équipé d'une marche arrière...)

In [34]:
print (x[2:-1]) # affichage depuis l'élément d'indice 2
                # jusqu'au dernier élément (non inclus)
                # l'indice -1 est celui du dernier élément
                #          -2 l'avant dernier, etc...

[  6.   8.  10.]

affichage des éléments d'un tableau 2D

In [35]:
MM = array([[1, 2, 3] , [10, 11, 12] , [20, 21, 22]]) # 3 lignes, 3 colonnes
print (MM[0,0])

1

Le premier indice pour les lignes

In [36]:
print (MM[2,0])

20

Le second pour les colonnes

In [37]:
print (MM[0,2])

3

Afficher tous les éléments d'une ligne...

In [38]:
print (MM[0,:]) # ligne "zéro"

[1 2 3]

...ou tous ceux d'une colonne

In [39]:
print (MM[:,1]) # colonne "un"

[ 2 11 21]

Tracé de courbes

Exercice 5 Premiers plots

  1. Utiliser les tableaux pour créer un programme de base permettant le tracé de courbes (on fait appel aux fonctions plot() et show() de la bibliothèque matplotlib)
In [40]:
#!/usr/bin/env python 
# -*- coding: utf-8 -*-
""" Programme minimal de tracé d’une fonction Python 3.x
"""
from scipy import *  
from pylab import * 
x = linspace(0, 10, 400) # on construit un tableau de 400 valeurs entre 0 et 10
y = sin(x)*exp(-x/5) # on construit le tableau des 400 valeurs de y correspondantes
plot(x,y, label=u"fonction $\sin(x)*\exp(-x/5)$")
legend()
show()

Quelques remarques

  • La ligne # -*- coding: utf-8 -*- permet de pouvoir utiliser des caractères accentués dans les textes (attention pas dans les noms des variables)
  • Il semble que le module de tracé matplotlib ne soit pas importé, en fait, il l'est mais dans pylab(de même que numpy).
  • numpy modifie les fonctions de base pour qu'elles soient capables d'effectuer, de manière transparente pour l'utilisateur, des calculs sur l'ensemble d'un tableau. (Ici la ligne donnant le tableau des y)
  • La syntaxe des légendes ou des textes reprend pour les notations mathématiques la syntaxe LaTeX

  1. Prenons l’exemple d’une molécule diatomique. L’énergie potentielle qui traduit l’interaction entre les deux atomes est souvent modélisée par une fonction analytique appelée « potentiel de Morse » dont voici l’expression en fonction de la distance interatomique $R$ :

    $$V(R)=D_e\left[1-exp(-\beta(R-R_{eq}))^2\right]$$

    Les paramètres $R_{eq}$ , $D_e$ et $\beta$ définissent respectivement :

    1. la distance interatomique à l’équilibre,

    2. la profondeur du puits de potentiel (égal à la différence d’énergie entre la situation à l’équilibre $R =R_{eq}$, et la situation dissociée $R = +\infty$) et

    3. la "largeur" du puits.

Reproduire la courbe de Morse pour la cas de la molécule $Cl_2$ ($R_{eq} = 0.198nm$, $D_e = 243 kJ.mol^{-1}$, $\beta = 20.0 nm^{-1}$ ).

In [41]:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" 
Potentiel de Morse Cl2
"""
from scipy import *
from pylab import *

req=1.98
de=243
beta=2.0
x = linspace(1, 6, 100)
y = de*(1-exp(-beta*(x-req)))**2

plot(x,y,'-o', label=u" $V \ (R)=D_e*(1-\exp(-\\beta*(R-R_{eq})))^2$")
title(u"Potentiel de Morse Cl$_2$", fontsize=16)     
xlabel(u"$R \ (\AA)$", fontsize=16)
ylabel(u"$V \ (kJ.mol^{-1})$", fontsize=16)
text(4,100, u"$D_e=243 \ kJ.mol^{-1}$", fontsize=14,color='k')
text(4,70, u"$R_{eq}=1,98 \AA$", fontsize=14,color='k')
text(4,40, u"$\\beta=2 \AA^{-1}$", fontsize=14,color='k')
axis([1,6,0,400])
legend()
show()

Quelques remarques

  • La syntaxe des formules mathématiques n'est pas exactement du LaTeX, en effet, le codes \ sont à la fois partagés par LaTeX et par les régles de syntaxe des caractères de commande dans de nombreux langages (C, C++, python, java, processing,...). Le caractère '\n'(attention il faut voir cette syntaxe comme celle d'un caractère unique et pas celle de deux caractères '\' et 'n') signfie passer à la ligne suivante (LF pour line feed). Le problème se pose alors lorsque vous voulez écrire une expression mathématique contenant par exemple les caractères $\nu$ ou $\nabla$ (nu ou nabla) dont la syntaxe est \nu ou \nabla. Le programme ne sait alors pas comment interpréter la chaîne ('\n' puis 'u'ou 'abla" ou alors $\nu$ ou $\nabla$). La solution adoptée est alors de doubler le signe \ quand il y a ambiguïté pour obtenir $\nu$ ou $\nabla$, on écrira donc \\nu ou \\nabla. C'est ce qui se passe dans le plot précédent pour $\beta$ puisque \b est aussi un caractère de contrôle.

Tracer sur la figure précédente les courbes représentant le potentiel de Morse des molécules

$F_2$ et $I_2$ caractérisées par les paramètres suivants :

  • $F_2$ : ($R_{eq} = 0.142nm$, $D_e = 150 kJ.mol^{-1}$, $\beta = 23.9nm^{-1}$)

  • $I_2$ : ($R_{eq} = 0.267nm$, $D_e = 148 kJ.mol^{-1}$, $\beta = 15.0nm^{-1}$)

Quelques indications :

  • le nom des axes est fixé grâce aux fonctions xlabel() et ylabel()

  • le titre est indiqué à l’aide de la fonction title()

  • les marqueurs de ligne sont donnés par : ’o’ pour les cercles, ’s’ pour les carrés (square), ’v’ pour les triangles pointe vers le bas et ’^’ pour les triangles pointes vers le haut

  • on peut fixer le domaine de représentation graphique à l’aide de la fonction axis([xmin,xmax,ymin,ymax]).

In [42]:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" 
Potentiel de Morse Cl2, F2 et I2
"""
from scipy import *
from pylab import *

#pour Cl2
req=1.98
de=243
beta=2.0
x = linspace(1, 6, 50)
y = de*(1-exp(-beta*(x-req)))**2
plot(x,y,'-o', label=u"$Cl_2$")

req=1.42
de=150
beta=2.39
y = de*(1-exp(-beta*(x-req)))**2
plot(x,y,'-s', label=u"$F_2$")

#pour I2
req=2.67
de=148
beta=1.50
y = de*(1-exp(-beta*(x-req)))**2
plot(x,y,'-v', label=u"$I_2$")


title(u"Potentiel de Morse $Cl_2$, $F_2$ et $I_2$", fontsize=16)     
xlabel(u"$R \ (\AA)$", fontsize=16)
ylabel(u"$V \ (kJ.mol^{-1})$", fontsize=16)
#text(4,100, ur"$D_e=243 \ kJ.mol^{-1}$", fontsize=14,color='k')
#text(4,70, ur"$R_{eq}=1,98 \AA$", fontsize=14,color='k')
#text(4,40, ur"$\beta=2 \AA^{-1}$", fontsize=14,color='k')
axis([1,6,0,400])
legend()
show()