Il existe plusieurs distributions de Python à destination des scientifiques :
Chacune de ces distributions est disponible pour un grand nombre d'architectures 32 et 64 bits (Linux, Windows, Mac OS...).
Courant 2014, Anaconda semble être l'offre la plus simple d'accès et qui offre la meilleure compatibilité multi-plateformes.
Il s'agit de la distribution installée par défaut sur les machines de la salle de TP.
Chacune de ces distributions comprend un ensemble de packages scientifiques (numpy, scipy, pandas...) et d'outils de développement (Spyder, Ipython). Python étant un langage ouvert, il est possible d'installer d'autres packages issus de la communauté ou de collègues.
Plusieurs outils de gestion des paquets existent. Par exemple, pour installer seaborn :
pip install seaborn
ou
conda install seaborn (uniquement pour la distribution Anaconda)
Ces outils se connectent à des dépots en ligne et gèrent intégralement le téléchargement des sources et leur installation.
Si un paquet n'est pas disponible dans les dépôts officiels, il existe plusieurs alternatives :
python setup.py install
Spyder est un environnement graphique de développement inspiré de l'interface Matlab.
Ses fonctionnalités comprennent :
In [23]:
print "Hello world"
In [24]:
print '1', # la virgule empèche le saut de ligne après le print
print '2'
In [25]:
a = 1 # int
b = 1. # float
print a
print b
In [26]:
# Les variables sont sensibles à la casse
print A
In [27]:
print(1+1.)
print 1+1
print 1/2
print 1./2
In [28]:
c = 1+2j
In [29]:
print c.real # real et un attribut de l'objet c
print c.imag # imag et un attribut de l'objet c
print c.conjugate() # Pourquoi des parenthèses ici? conjugate est une méthode de c
print c*c
print a+c
In [30]:
print True + True #True vaut 1, False vaut 0
print True & False
print (1 | False)
print not False
print a == b
print a is b
Pourquoi
a == b
retourne vrai alors que
a is b
retourne faux?
In [31]:
if a == 1 :
print "a == 1" # Notez les 4 espaces après le retour à la ligne.
# Un groupe d'instruction est marqué par un même niveau d'indentation
else :
print "a <> 1"
In [32]:
if a == 1 :
if type(a) == type(1.0) :
print "a is a float"
elif type(a) == type(1):
print 'a is an integer'
else :
print "a <> 1"
In [33]:
for i in [0,1,2,'a','test'] :
print i
In [50]:
range(3)
Out[50]:
In [34]:
i = 0
while i < 5:
i += 1 # identique à i = i + 1
print i
Exercice :
In [35]:
print "a"
print 'b' # on peut aussi bien utiliser ' que "
print "aujourd'hui"
Le concaténation des caractères se fait avec le signe +
In [52]:
print 'a'+'b'
print 'a'*5+'b'*4
Les caractères disposent de méthodes de manipulation, remplacement et de recherche :
In [37]:
print 'banana'.split('a')
print 'banana'.replace('n','l')
print 'banana'.capitalize()
print 'banana'.upper()
print '--'.join(['1','2','3','4'])
print 'banana'.count('na')
print "Python".find('on')
Les chaînes de caractères sont en fait des listes de caractères :
In [55]:
e = 'anticonstitutionnellement'
print len(e)
print e[0] # Comme en C, les listes commencent à 0
print e[-1] # l'élément -1 est le dernier élément, le -2 l'avant dernier...
print e[15:] # imprime tous les éléments après le 15ème
for i,char in enumerate(e) : # enumerate liste les éléments d'une liste et leur position
print i,char
In [56]:
e[0] = 'A' # les chaînes de charactères sont immutables
In [40]:
### Lecture d'un fichier ligne par ligne :
f = open('zen.txt','r')
print 'Ligne 0: '+ f.readline()
print 'Ligne 1: '+ f.readline()
print 'Ligne 2: '+ f.readline()
print 'Ligne 3: '+ f.readline()
f.close() # fermeture du fichier
# Si le fichier reste ouvert, il sera indisponible pour les autres programmes de l'OS
Une version plus efficace de la lecture de fichier est d'utiliser le mot clef with. Celui-ci crée un sous bloc de code qui, quoi qu'il arrive, exécute une action avant la sortie de code. Utilisé en conjonction avec open, with fermera toujours le fichier en fin de code.
In [255]:
with open('zen.txt','r') as f :
s = f.read()
print s
# à la fin execute f.__exit__() qui ferme le fichier
In [243]:
f.read()
In [145]:
print "%d"%42
print "La variable %s vaut %2.3f à l'itération %d"%('toto',3.14159,12.) # arguments positionnels
Il existe une autre syntaxe qui permet des expressions plus complexes :
In [148]:
print '{0}, {1}, {2}'.format('a', 'b', 'c')
print 'Coordinates: {latitude}N, {longitude}W {text}'.format(latitude=37.24, longitude=-115.81,text='Zen')
Pour aller plus loin avec les chaînes de caractères :
In [68]:
g = [1,2,3]
print g
print g[0] # Comme en C, les listes commencent par 0
g[1]='deux' # les listes sont modifiables ("mutable")
print g
print g[1][0] # accède au premier élément de l'élément 2 de la liste
print g[-1]
La liste est mutable, il est possible de lui ajouter des éléments
In [69]:
g.append(4)
print g
g.extend([5,6,7])
print g
Attention les variables en Python sont des pointeurs, c'est à dire une adresse qui pointe vers un objet dans la mémoire.
In [70]:
print g
g2 = g
g2[0] = 'un'
print g2
print g # La modification de la liste g2 entraine la modification de la liste g ... g et g2 pointent toutes les deux vers la même variable
Pour être sûr de créer un nouvel objet, il faut utiliser le module copy
In [71]:
from copy import copy
g2 = copy(g)
print g
g2[-1] = 'sept'
print g2
print g
La liste n'est qu'un container, elle ne réalise peu ou pas d'opérations numériques.
La liste n'est pas l'équivalent du vecteur (on verra plus tard le vecteur dans numpy)
In [73]:
print g+g
print g*3
# La liste se comporte comme la chaine de caractère. + est une opération de concaténation
Il existe des fonctions de création de liste comme range
In [77]:
h = range(1,4)
print h
Les listes possèdent également des méthodes de tri et de recherche d'éléments
In [78]:
h.append(0)
print h
h.sort()
print h
h.reverse()
print h
# Exercice : fabriquer une liste d'entier allant de 42 à 99 par pas de 4
In [231]:
cl = [ i**2 for i in range(5) ]
print cl
In [245]:
# Les tuples
g = (1,2,3) # on utilise des parenthèses à la place des crochets pour la création
print g
print g[0] # mais on indice des la même manière
In [244]:
g[1]='test' # les tuples ne sont pas modifiables ("immutable")
In [248]:
print g+g
print g*3
print g == [1,2,3]
print g == (1,2,3)
In [247]:
g.sort()
Les dictionnaires sont des containers qui relient une clef à une valeur. Les dictionnaires reposent sur des tables de hachage et ont une complexité en temps de l'ordre de $\mathcal{O}(1)$, c'est à dire que quelle que soit la taille d'un dictionnaire, le temps pour retrouver un élément est constant.
Cette performance vient avec une limitation : les clefs d'un dictionnaire sont nécessairement immutables (pour être précis, elles doivent être hashable). On ne peut donc pas utiliser de listes comme clef. On peut cependant utiliser un tuple. Il n'y a pas de limitation sur les valeurs. Tout les objets peuvent être stockés dans un dictionnaire.
In [249]:
k = {} # dictionnaire vide
k['A'] = [0,1,2,'trois',['toto']]
k["text"] = 'zen'
k[(0,1)] = 'tuple'
print k
In [250]:
k[[0,1]] = 'list' # renvoie une erreur
In [160]:
print k['A'] # retrouve la valeur associée à la clef 'A'
In [161]:
k.keys() # retourne la liste des clefs
Out[161]:
In [162]:
k.values() # retourne la liste des valeurs
Out[162]:
In [163]:
k.items() #retourne la liste des paires clefs values sous la forme d'une liste de tuples
Out[163]:
On peut créer un dictionnaire directement :
In [166]:
k2 = {1:'A',
2:'B',
3:'C'}
print k2
Ou bien à partir d'une liste de (clefs, valeurs)
In [234]:
k3 = dict( [('T','Température'),
('P','Puissance'),
('H','humidité')])
print k3
print 'T' in k3 # T est une clefs de k3
print 't' in k3
Exercice :
In [173]:
import string
print string.ascii_lowercase
Exercice :
In [256]:
from this import d
print d
In [181]:
k4 = {k: k**2 for k in range(10)}
print k4
| Header | Header | Header | Header |
|---|---|---|---|
| Cell | Cell | Cell | Cell |
| Cell | Cell | Cell | Cell |
| Cell | Cell | Cell | Cell |
| Cell | Cell | Cell | Cell |
In [84]:
a = 1
b = 2
print a
print b
a,b = b,a # permutation de variables
print a,b
In [80]:
a+b
Out[80]:
Un objet Python possède :
In [81]:
a.__doc__ # La documentation d'un objet est disponible dans son attribut __doc__
Out[81]:
In [82]:
print a.__add__ # la méthode __add__ permet d'additionner des variables entre elles.
print a.__add__(b)
Les méthodes et les attributs commençant et finissant par "__" sont des méthodes spéciales.
Par exemple, Python interprete toujours la méthode __add__ comme la méthode permettant d'additioner un objet avec un autre. La méthode __doc__ est appelée sur un objet lorsque que l'on invoque la commande help(objet)
Pour acceder à la liste des méthodes et des attributs d'un objet, vous pouvez taper dir(objet). En mode interactif dans Ipython, il suffit de taper un point à la suite du nom d'un objet et de faire tab.
Python est modulaire, il repose sur un écosystème de packages permettant d'enrichir ses fonctionnalités (ie : toolbox matlab gratuite)
Exemple : Le package datetime permet la manipulation des dates et du temps
In [112]:
import datetime
start = datetime.datetime(2015,3,4,8,30)
end = datetime.datetime(2015,3,4,18,30)
t = end-start
print start, end
print t
In [113]:
print start.isoweekday()
print start.strftime('%A %B %Y %H::%m::%S')
print t.seconds
Pour alléger les notations, il est possible de faire de imports relatifs :
In [122]:
from datetime import datetime, timedelta
dt = timedelta(hours=2,minutes=7,seconds=18)
print datetime.utcnow()
print datetime.utcnow()+dt
Exercice :
In [238]:
def fun2(a,b):
return a*b
print fun2('fun',5)
print fun2(12,5) # appel de fonction avec argument positionnel
print fun2(b=5,a=12) # appel de fonction avec argument par mot clef
print a # la valeur de la variable a n'a pas changé
In [ ]:
print a
def fun1():
print a
pass
print fun1()
Notez que a n'était pas passé en argument... Les variables à l'extérieur des fonctions sont accessible dans la fonction... mais pas l'inverse fun1 ne reroune aucune valeur, son résultat est
None
In [192]:
def fun3(a=0):
return a
print fun3() # Argument par défault
print fun3(4)
In [253]:
def fun4(param0, param1 = 1, param2 = 3.14 ):
"""
Documentation ici
"""
return param0*param1*param2, param0*param1
res1,res2 = fun4(1)
print res1, res2
print fun4(param0 = 1)
print fun4(param0=1, param1 = 1, param2 = 3.14 )
# Toutes les lignes sont strictement équivalentes
help(fun4)
On peut aussi définir des fonctions avec une liste d'arguments variable
In [230]:
def fun5(req0,req1,opt0=0.0, opt1='c',opt2={},**kwargs):
print req0
print req1
print opt0
print opt1
print opt2
print kwargs # key worded arguments
return None
print fun5(req0='a',req1='b',opt0=1,opt1=2,opt2=3,**{'toto':7,'tata':8})
Documentation de fonction avec le docstring (les triples quotes au début de la définition de la fonction)
In [202]:
def empty_documented_function(required_int,optional_float=0.0, optional_string='CSTB', *kargs ,**kwargs):
u"""
Mettre ici la description de ce que la fonction fait.
Des équations en ligne ici :math:`T_{ext}(t)\\geq0^{\\circ}C`
Des équations centrées ici :
.. math:: e_{sat}(t) = 610.5e^{\\frac{17.269.T_{ext}(t)}{273.3+T_{ext}(t)}}
Parameters
----------
required_int: int
required_int how great is the CSTB [1]_
optional_float : float
optional_float is an optional float. Default value is 0.0.
optional_string : string
optional_string is an optional string of character. Its default value is
*kargs : a list
Output shape. If the given shape is, e.g., ``(m, n, k)``, then
``m * n * k`` samples are drawn.
See Also
--------
myModule.myOtherFunctionDoingSimilarThing : also great.
References
----------
.. [1] CSTB, "Web site",
http://www.cstb.fr/
Examples
--------
>>> s = empty_function(2)
>>> len(s)
"""
s = ' '.join(['CSTB is']+['great']*required_int+['!'])
print s
return s
if __name__ == "__main__" :
print(u'Le module est executé en tant que script')
else :
print(u'Le module est importé')
regarder l'aide de empty_documented_function
Mise en page des équations : http://martinkeefe.com/math/mathjax1
Matrice, algère linéaire, optimization, traitement du signal :
Séries temporelles, données tabulaires : Pandas http://pandas.pydata.org/pandas-docs/dev/tutorials.html
Statistiques : statsmodels http://statsmodels.sourceforge.net/
Apprentissage machine : scikitlearn http://scikit-learn.org/stable/
Processeur solaire : Pysolar https://github.com/pingswept/pysolar/tree/0.6
Graphes :
Cartographie :
Analyse de sensibilité et propagation d'incertitude : OpenTurns (outils EDF) http://www.openturns.org/
Inversion Bayesienne : Pymc http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Chapter1.ipynb
Calcul symbolique : Sympy http://docs.sympy.org/latest/tutorial/intro.html
Automatisation du travail sous EnergyPlus : EPPY, http://www.datadrivenbuilding.org/
Lecture / écriture de fichier xml : lxml http://lxml.de/tutorial.html
Requête http : requests http://docs.python-requests.org/en/latest/user/quickstart/
Traitement de document html : beautifulSoup http://www.crummy.com/software/BeautifulSoup/bs4/doc/
In [5]:
%%javascript
console.log("Hello World!")
In [ ]: