Transcript Python - Les bases du langage

Python - Les bases du langage
Réunion COMICS
18 novembre 2011
Plan
Présentation de Python
Les types et les opérations de base
Les structures de contrôle
Les fonctions
Les fichiers
Les classes
Les exceptions
Les modules
Ressources
Présentation de Python
Développé en 1989 par Guido van Rossum
Open source
Portable (Windows, linux Mac OS)
Orienté objet
Dynamique
Extensible
Support pour l'intégration d'autre langage
Présentation de Python
Il existe 2 technique pour effectuer la traduction
en langage machine mon code source:
Interprétation: inconvénient lent!!!
Compilation: Rapide, inconvénient compilation
Présentation de Python
Et Python ???
Avantages:
Interpréteur permettant de tester n'importe quel petit bout
de code
Compilation transparente
Inconvénients:
Peut être lent
Présentation de Python
Les versions de Python
Il existe 2 version de Python: 2.7 et 3.1
La version 3.x n'est pas une simple amélioration ou
extension de 2.7
Portage pas totalement fini de 3.1
L'Interpréteur
2 choix entre python ou Ipython
Quelques options
-c: execute la commande python entrée après
-i passe en mode intéractif apres avoir exécuté un script ou une
commande
-d: passe en mode debug
Présentation de Python
Que peut-on faire avec Python?
Web
Django,Zope,Plone,...
Bases de données
MySQL,PostgrSQL,Oracle,...
Gui
Gtk+,Qt, Tcl/Tk, WxWidgets
Représentation graphique
gnuplot,matplotlib,VTK
Calcul scientifique
numpy, scipy, sage,...
…....
Présentation de Python
Pourquoi Python pour le calcul
Peut être appris en quelques jours
Permet de faire des tests rapides
Alternative à Matlab, Octave, Scilab
Parallélisation
Multiplateforme
Facilement interfaçable avec des librairies(Fortran,
C/C++) de calcul scientifique
Les types et les opérations de
base
Les types:
Entiers(32 bits)
Entiers longs
Réels (64 bits)
Complexe: 3+4j, ou 3+5J
Booléens ( True, False)
Les types et les opérations de
base
Opérations de base
Affectation:
>>> i=3 # i vaut 3
>>>a, pi=True, 3.14159
>>>k=r=2.15
Affichage dans l'interpréteur
>>> i
3
>>> print i
3
Les types et opérations de base
Opérations de base
Opérateurs +,-,*,/,%,//
Puissance **,pow,abs
Comparaison: ==, is, !=, is not, >,<,>=,<=
Opérateurs bitwise: &,|,<<,>>
Opérateurs logique: or,and, not
Aparté
En Python tout est objet
dir permet d'avoir les objets et méthodes
disponibles
eval evaluer les chaînes de caractères
help permet d avoir une aide
type connaître le type de l'objet
id l'adresse d'un objet
eval evaluer une chaîne de caractère
input et raw_input équivalent du scenf en C
Aparté
Ecriture d'un script python (test.py)
#!/usr/bin/env python
# -*- coding: utf-8 -*a=2
a
print type(a),a
Exécution python test.py
<type,'int'> 2
Les types et les opérations de
base
Les listes
Initialisation [ ],list(),[1, 2,3,4],['point','triangle',6],
range(10),range(2,10,2)
Concaténation
In [18]: sept_zeros=[0]*7;sept_zeros
Out[18]: [0, 0, 0, 0, 0, 0, 0]
In [20]: L1,L2=[1,2,3],[4,5]
In [21]: L1+L2
Out[21]: [1, 2, 3, 4, 5]
Une liste est une séquence comme pour une
chaîne de caractère
Les types et les opérations de
base
ATTENTION !!!!!
In [22]: L=['Dans','python','tout','est','objet']
In [23]: T=L
In [24]: T[4] ='bon'
In [25]: T
Out[25]: ['Dans', 'python', 'tout', 'est', 'bon']
In [26]: L
Out[26]: ['Dans', 'python', 'tout', 'est', 'bon']
In [27]: L=T[:]
In [28]: L[4]='objet'
In [29]: T;L
Out[29]: ['Dans', 'python', 'tout', 'est', 'bon']
Out[29]: ['Dans', 'python', 'tout', 'est', 'objet']
Les types et les opérations de
base
Une liste à ses propres méthodes help(list)
len(L) : taille de la liste
L.sort() : trier la liste
L.append() ajout element en fin de,liste
L.reverse(): inversion de la liste
L.index() recher elt dans L
L.remove(): retirer element
L.pop() ajout en fin de liste
Les types et les opérations de
base
Les tuples
Initialisation:
(),tuple(),(1,) 'a','b','c',
('a','b','c')
Concaténation
>>>(1,2)*3
>>> (1,2,1,2,1,2)
In [1]: t1,t2=(1,2,3),(4,5)
In [2]: t1+t2
Out[2]: (1, 2, 3, 4, 5)
Un tuple est aussi une séquence.
Les types et les opérations de
base
Opération sur un tuple
Un tuple n'est pas modifiable
In [3]: t='a','b','c','d'
In [4]: t[0]='alpha'
TypeError
Traceback (most recent call last)
TypeError: 'tuple' object does not support item assignment
In [6]: t=('alpha',)+t[1:]
In [7]: t
Out[7]: ('alpha', 'b', 'c', 'd')
Mais un objet modifiable dans un tuple peut l'êtret
In[8]: t=(1,2,[3,4],6)
In[9]:t[2][0]=1;t
Out[9]: (1,2,[1,4],6)
Les types ete les opérations de
base
Les dictionnaires:
Initialisation {}, dict(), {'point':1,'ligne':2}
Un dictionnaire est constitué de clés et de valeurs
Pas de concaténation possible
Ajout d une clé ou modif d'une valeur
>>> dic['triangle']=3
>>> dic
{'ligne': 2, 'triangle': 3, 'point': 1}
>>> dic['point']=3
>>> dic
{'ligne': 2, 'triangle': 3, 'point': 3}
Les types et ls opérations de
base
Dictionnaire a ses propres méthodes:
len(dic) taille du dictionnaire
Dico.keys renvoie les clés
Dic.value renvoie les valuers
Dic.has_key renvoie True si clé presente
Dic.get donne valeur de la clé si elle existe
sinon une valeur par défaut
Les structures de contrôle
Indentation générale
Structure de contrôle
Structure if then
a=10.
if a>0:
print ' est positif'
if a>=10:
print'a est un nombre'
else:
print ' a est un chiffre'
a+=1
elif a is not 0:
print 'a est negatif
else:
print'a est nul'
Structure while
While <test1>:
<bloc instruction>
if <test1>: break
if <test2> : continue
Else:
<bloc instruction>
Structure de contrôle
For <cible> in <objet>:
<bloc instruction>
if <test1>: break
if <test2> : continue
else:
<bloc instruction>
sum =0
for i in [1,2,3,4]:
sum+=i
prod=1
for p in range(1,10):
prod*= p
s='bonnjour'
for c in s:
print c
Les fonctions
Syntaxe:
def <nom_fonction>( arg1,arg2,.....):
<bloc instruction>
return valeur
Exemple:
def table(base):
N=1
while n<11:
print n*base,
N+=1
return n
Les fichiers
f=open(filename, mode='r', bufsize=-1)
'r' le fichier qui doit déja exister ouvert en lecture
'w' en ecriture seule si il existe déjà il est écrsé et
créé sinon
'b' ouvre un fichier binaire
Option '+' ouvre en lectuere et écriture
'a' en écriture son contenu est conservé
Les méthode:close(),read() et renvoie sous forme
de chaîne, readline() lit une ligne du fichier,
readlines(), write(s) ecrit la chaine s,
writelines(lst)
Les classes
Syntaxe:
classe <nom_classe>(superclass,....):
donnee=valeur
def methode(self,....):
self.membre=valeur
Exemple classe vecteur:
Les classes
class vecteur:
def __init__(self, x, y, z = 0):
self.coords = [x, y, z]
def __str__(self):
s = ''
for c in self.coords:
s += '( ' + str(c) + ' )\n'
return s
def __add__(self, v):
return vecteur(self.coords[0] +
v.coords[0],
self.coords[1] + v.coords[1],
self.coords[2] + v.coords[2])
>>> v1 = vecteur(1, 2)
>>> v2 = vecteur(4.1, 3.4, 1.)
>>> v3 = v1 + v2
>>> print v3
( 5.1 )
( 5.4 )
( 1.0 )
NumPy
▶Le module incontournable
▬ Heritier
de Numeric et numarray
▬ Classes de base pour SciPy
▶Installation
▬ Module
Python standard
▬ Optimisation plateforme: blas, lapack...
▶Utilisation
▬ Traitement
Python des tableaux pour calcul numerique
◆ Nombreuses
fonctions de manipulation
◆ Bibliothèque mathématique importante
▬ Support
◆ Interface
pour vos propres bibliotheques
Python pur
◆ API pour encapsulation de codes Fortran, C/C++
Le tableau NumPy
▶ndarray
▬ L'objet
Tableau
Collection indexable et contigue en mémoire d‘éléments de même type
◾ Implémentation avec un vrai tableau en mémoire optimise pour les performances
◾ Manipulation similaire a tout autre objet Python
◾
◾
▬ Multi-dimensionnel,
tous types de données
Les dimensions et parcours sont modifiables, les indexations souples
◾ Optimisations internes pour les 1D, 2D et 3D
◾
◾
▬ Interfaçable
avec les codes, en particulier Fortran
Permet l'encapsulation de codes fortran
◾ Gestion possible des interfacages multiples Fortran/C/C++
◾
Appel au module
>>> import numpy
Creation – 1
▶La création d'un tableau définit...
▬ Son
◾
contenu
Par exemple sous forme d'une liste de valeurs
a=array([1,3,5,7,9,11,13,17])
▬ Ses
dimensions
Une liste: dimension 1, une liste de listes: dimension 2, une liste de listes de listes: dimension
3...
◾
a=array([0.1, 0.0, 0.2])
b=array([[1,2,3],[4,5,6]])
▬ Son
type d'element
Un entier Python est un long, un reel est un double
◾ Il est necessaire de preciser si les valeurs en arguments ne sont pas les types Python
◾
a=array([0.1, 0.0, 0.2],dtype='f')
b=array([[1,2,3],[4,5,6]],dtype='i')
Creation – 2
▶Diverses methodes de creation
>>> a=arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a=zeros((2,4),dtype='f')
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]], dtype=float32)
>>> a=ones((3,5))*nan
array([[ nan, nan, nan, nan, nan],
[ nan, nan, nan, nan, nan],
[ nan, nan, nan, nan, nan]])
>>> a=identity(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> a=mat([[1,0],[0,1]])
matrix([[1, 0],
[0, 1]])
Creation – 3
▬ Fonction
des indices
>>> def initfunction(i,j):
... return 100+10*i+j
>>> c=fromfunction(initfunction,(5,3))
array([[ 100., 101., 102.],
[ 110., 111., 112.],
[ 120., 121., 122.],
[ 130., 131., 132.],
[ 140., 141., 142.]])
▬ A partir
d'un fichier
>>> import numpy
>>> a=numpy.ones((3,5,7))
>>> numpy.save("data.npy",a)
>>> b=numpy.load("data.npy")
Attributs – 1
▶flat
▬ Vue
◆ Pas
1D d'un tableau
de modification du tableau
◆ Iterateur
>>> a=indices((2,5))
>>> a
array([[[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1]],
[[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]]])
>>> a.flat
<numpy.flatiter object at 0xc9db80>
>>> a.flat[0]
0
>>> a.flat[:]
array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
>>>
Attributs – 2
▶shape
▬ Tuple
des dimensions d'un tableau
Attribut accessible en lecture et en ecriture
>>> a=ones((3,5,7))
>>> a.shape
(3,5,7)
>>> a.shape=(21,5)
>>> shape(a)
(21,5)
▬ Le
nombre d'elements doit rester inchange
len(a.flat) = Constante
▬ La
methode reshape permet aussi de changer le shape
>>> a=arange(105).reshape((3,5,7))
Attributs – 3
▶Fortran
▬ Type
d'implantation memoire
◆C
(par defaut) line major, Boucle en i,j,k
◆ Fortran column major, Boucle en k,j,i
▬ Pas
d'impact sur le shape
>>> a=ones((2,3,4),order='Fortran')
>>> isfortran(a)
True
▶OwnData
▬ Python
est proprietaire de la zone memoire
>>> a.flags.owndata
True
Indexation – 1
▶Un element dans le tableau
▬ Syntaxe
similaire aux sequences
>>> a=arange(24).reshape(2,3,4)
>>> a[0][2][1]
9
>>> a[0][0:1]
array([[0, 1, 2, 3],[4, 5, 6, 7]])
▬ Syntaxe
avec implementation optimisee pour l'acces
>>> a[0,2,1]
9
>>> a[0,0:1]
array([[0, 1, 2, 3],[4, 5, 6, 7]])
▬ La
syntaxe fonctionne pour la la reference et l'assignation
>>> b=a[0:2]
>>> a[0:2]=9
Indexation - 2
▬ Prendre
un axe complet
>>> a=arange(24).reshape(2,3,2,2)
>>> a.tolist()
[[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]],
[[[12, 13],
[14, 15]], [[16, 17], [18, 19]], [[20, 21], [22, 23]]]]
>>> a[0,:,:,0]
array([[ 0, 2],
[ 4, 6],
[ 8, 10]])
>>> a[0,...,0]
Indexation - 3
▶Ajout du step
▬ [<start>:<stop>:<step>]
>>> a=arange(24).reshape(2,6,2)
>>> a
array([[[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7],
[ 8, 9],
[10, 11]],
[[12, 13],
[14, 15],
[16, 17],
[18, 19],
[20, 21],
[22, 23]]])
>>> a[0]
array([[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7],
[ 8, 9],
[10, 11]])
>>> a[0,::2]
array([[0, 1],
[4, 5],
[8, 9]])
>>> a[0,::2,:1]
array([[0],
[4],
[8]])
Ufuncs - 1
▶Universal functions
▬ Opere sur un tableau element par element
◾ add(a,b) avec a et b ndarrays est plus performant qu'une boucle
▬ Vectorisable
◾ Une fonction prend des vecteurs en entree et produit un vecteur en sortie
◾ L'utilisateur peut utiliser l'API pour creer ses propres ufuncs
▬ Broadcasting
◾ Il est parfois necessaire de faire des adaptations pour que les vecteurs en
entree aient la meme taille
◾ a=array([1,2,3,4,5])*2
◾ Provoque le broadcasting b=array([2,2,2,2,2])
▬ Syntaxe compacte
◾ Pas de boucles
◾ Parfois difficile a lire
>>> x=arange(10)
>>> x[(x**39*
x**2+23*x15)==
0]
array([1, 3, 5])
Ufuncs – 2
sin() Trigonometric sine, element-wise.
cos() Cosine elementwise.
tan() Compute tangent element-wise.
arcsin() Inverse sine, element-wise.
arccos() Trigonometric inverse cosine, element-wise.
arctan() Trigonometric inverse tangent, elementwise.
add(x1) Add arguments element-wise.
subtract(x1) Subtract arguments, element-wise.
multiply(x1) Multiply arguments element-wise.
divide(x1) Divide arguments element-wise.
logaddexp(x1) Logarithm of the sum of exponentiations of the inputs.
logaddexp2(x1) Logarithm of the sum of exponentiations of the inputs in base-2.
true_divide(x1) Returns a true division of the inputs, element-wise.
floor_divide(x1) Return the largest integer smaller or equal to the division of the
inputs.
negative() Returns an array with the negative of each element of the original
array.
power(x1) First array elements raised to powers from second array, element-wise.
remainder(x1) Return element-wise remainder of division.
mod(x1) Return element-wise remainder of division.
fmod(x1) Return the element-wise remainder of division.
absolute() Calculate the absolute value element-wise.
rint() Round elements of the array to the nearest integer.
sign() Returns an element-wise indication of the sign of a number.
conj() Return the complex conjugate, element-wise.
exp() Calculate the exponential of all elements in the input array.
exp2() Calculate 2**p for all p in the input array.
log() Natural logarithm, element-wise.
log2() Base-2 logarithm of x.
log10() Return the base 10 logarithm of the input array, element-wise.
expm1() Calculate exp(x) - 1 for all elements in the array.
log1p() Return the natural logarithm of one plus the input array, element-wise.
sqrt() Return the positive square-root of an array, element-wise.
square() Return the element-wise square of the input.
reciprocal() Return the reciprocal of the argument, element-wise.
ones_like() Returns an array of ones
……………………………………………..
F2py
f2py nécessite l’installation de Numpy et trois méthodes pour
créer une interface sont proposées :
• Interfacer des subroutines simples sans écrire de code
supplémentaire.
• Ajouter des directives pour f2py dans le source Fortran
pour un interfaçage plus complexe.
• Écrire un fichier d’interface décrivant les subroutines et
les données à interfacer. f2py génère automatiquement
un fichier d’interface simple qu’on peut ensuite éditer et
modifier.
Exemple de subroutine simple
Calcul de la norme.
Fortran 90/95 format libre
subroutine norme (a, b, c)
real(8), intent(in) :: a, b
real(8), intent(out) :: c
c= sqrt (a*a+b*b)
end subroutine norme
Fortran 77 format fixe
subroutine norme (a, b, c)
real*8 a,b,c
Cf2py intent(out) c
c=sqrt (a*a+b*b)
end
Compilation et exécution
• Génération de l’interface Python avec f2py
f2py -c norme.f90 -m vect --fcompiler=gnu95 --f90flags=-O3
• Appel depuis un shell Python
>>> import vect
>>> vect.norme(3,4)
5.0
>>> c = vect.norme(3,4)
>>> c
5.0
• Documentation générée automatiquement par f2py
>>> print vect.norme.__doc__
norme - Function signature :
c = norme(a,b)
Required arguments :
a : input float
b : input float
Return objects :
c : float
Ajout de directive f2py dans le source Fortran
Ces ajouts dans le code source fortran permettent préciser le
rôle et la définition des variables d’entrés-sorties. Sont
utilisés :
• Les attributs du F90 : intent(in), dimension(2,3 .
• Les attributs spécifiques : !f2py intent(hide), depend(a).
)
subroutine norme(a,c,n)
integer :: n
real(8),dimension(n),intent(in) :: a
!f2py optional , depend(a) :: n=len(a)
real(8),intent(out) :: c
real(8) :: sommec
integer :: i
sommec = 0
do i=1,n
sommec=sommec+a( i )*a( i )
end do
c=sqrt (sommec)
end subroutine norme
Liste Python ou tableau numpy en
argument
>>> from vect import *
>>> a=[2,3,4] #Une liste Python
>>> type(a)
<type 'list'>
>>> norme(a)
5.3851648071345037
>>> from numpy import *
>>> a=arange(2,5) # Un tableau numpy
>>> type(a)
<type 'numpy.ndarray'>
>>> norme(a)
5.3851648071345037
>>> print norme.__doc__ # Documentation
norme - Function signature :
c = norme(a,[n])
Required arguments :
a : input rank-1 array('d') with bounds (n)
Optional arguments :
n := len(a) input int
Return objects :
c : float
Utilisation d’un fichier signature
• On peut générer automatiquement un fichier signature
f2py vecteur.f90 -h vecteur.pyf
• Contenu de vecteur.pyf
! -*- f90 -*! Note: the context of this file is case sensitive.
subroutine norme(a,c,n) ! in norme.f90
real(kind=8) dimension(n),intent(in) :: a
real(kind=8) intent(out) :: c
integer optional,check(len(a)>=n),depend(a) :: n=len(a)
end subroutine norme
! This file was auto-generated with f2py (version:2).
! See http://cens.ioc.ee/projects/f2py2e/
Les tableaux multi dimensionnels
subroutine move( positions, vitesses, dt, n)
integer, intent(in) :: n
real(8), intent(in) :: dt
real(8), dimension(n,3), intent(in) :: vitesses
real(8), dimension(n,3) :: positions
do i = 1, n
positions(i,:) = positions(i,:) + dt*vitesses(i,:)
end do
end subroutine move
>>> print vitesses
[[0, 1, 2], [0, 3, 2], [0, 1, 3]]
>>> print positions
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> move(positions, vitesses, 0.1)
>>> print positions #le tableau n'est pas mis a jour, stockage C
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> positions = numpy.array(positions, dtype='f8', order='F')
>>> move(positions, vitesses, 0.1)
>>> print positions #le tableau est modifie, stockage Fortran
[[ 0. 0.1 0.2]
[ 0. 0.3 0.2]
[ 0. 0.1 0.3]]