Alexandre Gramfort : alexandre.gramfort@telecom-paristech.fr
Slim Essid : slim.essid@telecom-paristech.fr
adapté du travail de J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/
Sous Ubuntu Linux:
$ sudo apt-get install python ipython ipython-notebook
$ sudo apt-get install python-numpy python-scipy python-matplotlib python-sympy
$ sudo apt-get install spyder
Anaconda CE est aussi disponible sous Linux
Tapez dans un terminal:
$ export PATH=/cal/softs/anaconda/anaconda-latest/bin/:$PATH
Un fichier python termine par ".py
":
mon_programme.py
Toutes les lignes d'un fichier Python sont excécutées sauf les lignes qui commencent par #
qui sont des commentaires.
Pour lancer le programme depuis une ligne de commande ou un terminal:
$ python mon_programme.py
Sous UNIX (Linux / Mac OS) il est courant d'ajouter le chemin vers l'interpréteur python sur la première ligne du fichier:
#!/usr/bin/env python
Cela permet de lancer un progamme directement:
$ mon_programme.py
ls scripts/hello-world.py
cat scripts/hello-world.py
!./scripts/hello-world.py
Commencer une ligne par ! dans ipython permet de lancer une commande UNIX.
L'interpréteur Python se lance avec la commande python
. Pour sortir taper exit()
ou Ctrl+D
IPython est un shell interactif beaucoup plus avancé.
Il permet notamment de:
IPython notebook comme Mathematica ou Maple dans une page web.
Pour lancer ipython-notebook:
$ ipython notebook
depuis un dossier où seront stockés les notebooks (fichiers *.ipynb)
2 + 2 + 1 # commentaire
a = 4
print a
print type(a)
Les noms de variable peuvent contenir a-z
, A-Z
, 0-9
et quelques caractères spéciaux tels que _
mais commencent toujours par une lettre.
Par convention les noms de variables sont en minuscule.
Quelques noms de variable ne sont pas autorisés car déjà utilisés par le langage:
and, as, assert, break, class, continue, def, del, elif, else, except,
exec, finally, for, from, global, if, import, in, is, lambda, not, or,
pass, print, raise, return, try, while, with, yield
int a = 1; # in C
c = 2.1 # nombre flottant
print type(c)
a = 1.5 + 1j # nombre complexe
print a.real
print a.imag
print 1j
print a
print a + 1j
print 1j * 1j
print type(a)
type(1j * 1j)
3 < 4 # bool
1 < 3 < 5
3 < 2
test = (3 > 4)
print test
type(test)
print 7 * 3. # int x float -> float
print type(7 * 3.)
2 ** 10 # exposant. attention pas ^
8 % 3 # reste de la division (modulo)
Attention !
3 / 2 # int x int -> int
3 / 2. # OK
3 // 2
a = 2
3 / float(a) # OK
MAIS:
cos(2)
import math
import math
x = math.cos(2 * math.pi)
print x
Ou bien en important que les fonctions dont on a besoin:
from math import cos, pi
x = cos(2 * pi)
print x
from math import *
tanh(1)
import math as m
print m.cos(1.)
dir
:import math
print dir(math)
help
help(math.log)
math.log?
math.log(10)
math.log(10, 2)
math.ceil(2.5)
help
peut être aussi utilisée sur des modules :help(math)
Modules utiles de bibliothèque standard: os
, sys
, math
, shutil
, re
, etc.
Pour une liste complète, voir: http://docs.python.org/2/library/
n
¶import math as m
# à compléter
import fractions
a = fractions.Fraction(2, 3)
b = fractions.Fraction(1, 2)
print(a + b)
isinstance
pour tester les types des variables :print type(a)
print isinstance(a, fractions.Fraction)
a = fractions.Fraction(1, 1)
print(a)
print(type(a))
x = 1.5
print x, type(x)
x = int(x)
print x, type(x)
z = complex(x)
print z, type(z)
x = float(z)
print x, type(x)
1 + 2, 1 - 2, 1 * 2, 1 / 2 # + - / * sur des entiers
1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0 # + - / * sur des flottants
# Division entière
3.0 // 2.0
# Attention ** et pas ^
2 ** 2
and
, not
, or
. True and False
not False
True or False
>
, <
, >=
(plus grand ou égal), <=
(inférieur ou égal), ==
equalité, is
identique.2 > 1, 2 < 1
2 > 2, 2 < 2
2 >= 2, 2 <= 2
2 != 3
not 2 == 3
int(True)
int(False)
1 == True
s = 'Hello world!'
# ou avec " "
s = "Hello world!"
print s
print type(s)
Attention: les indices commencent à 0!
On peut extraire une sous-chaine avec la syntaxe [start:stop]
, qui extrait les caractères entre start
et stop
(exclu) :
s[0] # premier élément
s[-1] # dernier élément
s[1:5]
start, stop = 1, 5
print s[start:stop]
print len(s[start:stop])
print stop - start
print start
print stop
Attention car :
len("é")
Mais:
len(u"é") # chaine de caractères unicode
On peut omettre start
ou stop
. Dans ce cas les valeurs par défaut sont respectivement 0 et la fin de la chaine.
s[:5] # 5 premières valeurs
s[6:] # de l'entrée d'indice 6 à la fin
print(len(s[6:]))
print(len(s) - 6)
s[-6:] # les 6 derniers
Il est aussi possible de définir le step
(pas d'avancement) avec la syntaxe [start:stop:step]
(la valeur par défaut de step
est 1):
s[1::2]
s[0::2]
Cette technique est appelée slicing. Pour en savoir plus: http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice et http://docs.python.org/2/library/string.html
import string
alphabet = string.ascii_lowercase
print "str1", "str2", "str3" # print ajoute des espaces entre les chaînes
print "str1", 1.0, False, -1j # print convertit toutes les variables en chaînes
print "str1" + "str2" + "str3" # pour concatener +
print "str1" * 3
a = 1.0000000002
print "val = %e" % a # comme en C (cf. printf)
print "val = %1.15f" % a # comme en C (cf. printf)
print "val = % 3d" % 10 # comme en C (cf. printf)
print "val = %s" % a # comme en C (cf. printf)
print str(a)
print "val = " + str(a)
# Plus avancé
s = "val1 = %.2f, val2 = %d" % (3.1415, 1.5)
print s
s = "Le nombre %s est égal à %s"
print(s % ("pi", math.pi))
print(s % ("e", math.exp(1.)))
Les listes sont très similaires aux chaînes de caractères sauf que les éléments peuvent être de n'importe quel type.
La syntaxe pour créer des listes est [...]
:
l = [1, 2, 3, 4]
print type(l)
print l
Exemples de slicing:
print l[1:3]
print l[::2]
Attention: On commence à indexer à 0!
l[0]
l[-1:0:-1]
On peut mélanger les types:
l = [1, 'a', 1.0, 1-1j]
print l
On peut faire des listes de listes (par exemple pour décrire un arbre...)
list_of_list = [1, [2, [3, [4, [5]]]]]
list_of_list
arbre = [1, [2, 3]]
print arbre
La fonction range
pour générer une liste d'entiers:
start, stop, step = 10, 30, 2
print(range(start, stop, step))
print(range(10, 30, 2))
print(list(range(10, 30, 2)))
Intération de n-1 à 0
n = 10
print(range(n-1, -1, -1))
type(range(-10, 10))
# convertir une chaine de caractère en liste
s = "zabcda"
l2 = list(s)
print(l2)
# tri
l3 = list(l2)
l2.sort()
print(l2)
print(l3)
print(l2[::-1]) # avec copie
Attention l2.sort() ne renvoie rien c'est-à-dire None
out = l2.sort()
print(out)
Pour renvoyer une nouvelle liste triée:
l2 = list(s)
print(l2)
out = sorted(l2)
print(out)
# création d'une liste vide
l = [] # ou l = list()
# ajout d'éléments avec `append`
m = l.append("A")
l.append("d")
l.append("d")
print(m)
print(l)
Concatenation de listes avec +
l
l.index('A')
lll = [1, 2, 3]
mmm = [4, 5, 6]
print(lll + mmm) # attention différent de lll.append(mmm)
print(lll * 2)
On peut modifier une liste par assignation:
l[1] = "p"
l[2] = "p"
print(l)
l[1:3] = ["d", "d"]
print(l)
Insertion à un index donné avec insert
l.insert(0, "i")
l.insert(1, "n")
l.insert(2, "s")
l.insert(3, "e")
l.insert(4, "r")
l.insert(5, "t")
print(l)
Suppression d'un élément avec 'remove'
l.remove("A")
print(l)
ll = [1, 2, 3, 2]
print(ll)
ll.remove(2)
print(ll)
print(2 in ll)
print(ll.index(2))
Suppression d'un élément à une position donnée avec del
:
del l[7]
del l[6]
print(l)
help(list)
pour en savoir plus.
Les tuples (n-uplets) ressemblent aux listes mais ils sont immuables : ils ne peuvent pas être modifiés une fois créés.
On les crée avec la syntaxe (..., ..., ...)
ou simplement ..., ...
:
point = (10, 20)
print(point, type(point))
point[0]
p2 = list(point)
p2[1] = 5
print(point, p2)
Un tuple peut être dépilé par assignation à une liste de variables séparées par des virgules :
x, y = point
print("x =", x)
print("y =", y)
On ne peut pas faire :
point[0] = 20
Ils servent à stocker des données de la forme clé-valeur.
La syntaxe pour les dictionnaires est {key1 : value1, ...}
:
params = {"parameter1" : 1.0,
"parameter2" : 2.0,
"parameter3" : 3.0}
# ou bien
params = dict(parameter1=1.0, parameter2=2.0, parameter3=3.0)
print(type(params))
print(params)
d = {0: 'aqdf', 1:"qsdf"}
d[0]
notes = {"dupont": 15, "durant":8}
print(notes["dupont"])
notes["dupont"] = 20
del notes["dupont"]
print(notes)
print("dupont" in notes)
print("parameter1 =", params["parameter1"])
print("parameter2 =", params["parameter2"])
print("parameter3 =", params["parameter3"])
params["parameter1"] = "A"
params["parameter2"] = "B"
# ajout d'une entrée
params["parameter4"] = "D"
print("parameter1 =", params["parameter1"])
print("parameter2 =", params["parameter2"])
print("parameter3 =", params["parameter3"])
print("parameter4 =", params["parameter4"])
Suppression d'une clé:
del params["parameter4"]
print(params)
Test de présence d'une clé
"parameter1" in params
"parameter6" in params
params["parameter6"]
a = 3
b = 2
if a < b:
print "a est strictement inférieur à b"
elif a > b:
print "b est strictement inférieur à a"
else:
print "b est égal à a"
statement1 = a < b
statement2 = a > b
if statement1 is True:
print "a est strictement inférieur à b"
elif statement2 is True:
print "b est strictement inférieur à a"
else:
print "b est égal à a"
statement1 = False
statement2 = False
if statement1:
print("statement1 is True")
elif statement2:
print("statement2 is True")
else:
print("statement1 and statement2 are False")
En Python l'indentation est obligatoire car elle influence l'exécution du code
Examples:
statement1 = True
statement2 = True
if statement1:
if statement2:
print("both statement1 and statement2 are True")
print (2 == 2) == 1
print 2 == 2 == 1
# Mauvaise indentation!
if statement1:
if statement2:
print("both statement1 and statement2 are True")
statement1 = True
if statement1:
print("printed if statement1 is True")
print("still inside the if block")
statement1 = False
if statement1:
print("printed if statement1 is True")
print("still inside the if block")
Boucles for
:
for x in [1, 2, 3]:
print(x)
La boucle for
itère sur les éléments de la list fournie. Par exemple:
for x in range(4): # par défault range commence à 0
print(x)
Attention range(4)
n'inclut pas 4 !
for x in range(-3,3):
print(x)
for word in ["calcul", "scientifique", "en", "python"]:
print(word)
for c in "calcul":
print(c)
Pour itérer sur un dictionnaire::
for key, value in params.items():
print(key, " = ", value)
for key in params:
print(key)
Parfois il est utile d'accéder à la valeur et à l'index de l'élément. Il faut alors utiliser enumerate
:
for idx, x in enumerate(range(-3,3)):
print(idx, x)
s = "HelLo WorLd!!"
Ecrire un code de codage et de décodage
code = {'e':'a', 'l':'m', 'o':'e'}
s = 'Hello world!'
# s_code = 'Hamme wermd!'
Compréhension de liste: création de liste avec for
:
ll = [x ** 2 for x in range(0,5)]
print(ll)
# est la version courte de :
ll = list()
for x in range(0, 5):
ll.append(x ** 2)
print(ll)
# pour les gens qui font du caml
print(map(lambda x: x ** 2, range(5)))
Boucles while
:
i = 0
while i < 5:
print(i)
i = i + 1
print("OK")
Une fonction en Python est définie avec le mot clé def
, suivi par le nom de la fonction, la signature entre parenthèses ()
, et un :
.
Exemples:
def func0():
print("test")
func0()
Ajout d'une documentation (docstring):
def func1(s):
"""
Affichage d'une chaine et de sa longueur
"""
print(s, "est de longueur", len(s))
help(func1)
print(func1("test"))
print(func1([1, 2, 3]))
Retourner une valeur avec return
:
def square(x):
"""
Returne le carré de x.
"""
return x ** 2
print(square(4))
Retourner plusieurs valeurs:
def powers(x):
"""
Retourne les premières puissances de x.
"""
return x ** 2, x ** 3, x ** 4
print(powers(3))
x2, x3, x4 = powers(3)
print(x2, x3)
print(type(powers(3)))
out = powers(3)
print(len(out))
print(out[1])
t = (3,)
print(t, type(t))
x2, x3, x4 = powers(3)
print(x3)
Il est possible de fournir des valeurs par défault aux paramètres:
def myfunc(x, p=2, debug=False):
if debug:
print("evalue myfunc avec x =", x, "et l'exposant p =", p)
return x**p
Le paramètre debug peut être omis:
myfunc(5)
myfunc(5, 3)
myfunc(5, debug=True)
On peut expliciter les noms de variables et alors l'ordre n'importe plus:
myfunc(p=3, debug=True, x=7)
La page wikipedia décrivant l’algorithme de tri quicksort donne le pseudo-code suivant:
function quicksort('array')
if length('array') <= 1
return 'array'
select and remove a pivot value 'pivot' from 'array'
create empty lists 'less' and 'greater'
for each 'x' in 'array'
if 'x' <= 'pivot' then append 'x' to 'less'
else append 'x' to 'greater'
return concatenate(quicksort('less'), 'pivot', quicksort('greater'))
Transformer ce pseudo-code en code valide Python.
Des indices:
len(l)
l1 + l2
l.pop()
retire le dernier élément d’une listeAttention: une liste est mutable...
Il vous suffit de compléter cette ébauche:
def quicksort(ll):
# ...
return
quicksort([-2, 3, 5, 1, 3])
Les classes sont les éléments centraux de la programmation orientée objet
Classe: structure qui sert à représenter un objet et l'ensemble des opérations qui peuvent êtres effectuées sur ce dernier.
Dans Python une classe contient des attributs (variables) et des méthodes (fonctions). Elle est définie de manière analogue aux fonctions mais en utilisant le mot clé class
. La définition d'une classe contient généralement un certain nombre de méthodes de classe (des fonctions dans la classe).
self
: argument obligatoire. Cet objet self
est une auto-référence.__init__
: nom de la méthode invoquée à la création de l'objet__str__
: méthode invoquée lorsque une représentation de la classe sous forme de chaîne de caractères est demandée, par exemple quand la classe est passée à print
class Point(object):
"""
Classe pour représenter un point dans le plan.
"""
def __init__(self, x, y):
"""
Creation d'un nouveau point en position x, y.
"""
self.x = x
self.y = y
def translate(self, dx, dy):
"""
Translate le point de dx and dy.
"""
self.x += dx
self.y += dy
def __str__(self):
return "Point: [%f, %f]" % (self.x, self.y)
Pour créer une nouvelle instance de la classe:
p1 = Point(x=0, y=0) # appel à __init__
print(p1.x)
print(p1.y)
print("%s" % p1) # appel à la méthode __str__
p1.translate(dx=1, dy=1)
print(p1)
print(type(p1))
Pour invoquer une méthode de la classe sur une instance p
de celle-ci:
p2 = Point(1, 1)
p1.translate(0.25, 1.5)
print(p1)
print(p2)
try
- except
Une utilisation typique: arrêter l'exécution d'une fonction en cas d'erreur:
def my_function(arguments):
if not verify(arguments):
raise Expection("Invalid arguments")
# et on continue
On utilise try
et expect
pour maîtriser les erreurs:
try:
# normal code goes here
except:
# code for error handling goes here
# this code is not executed unless the code
# above generated an error
Par exemple:
try:
print("test_var")
# genere une erreur: la variable test n'est pas définie
print(test_var)
except:
print("Caught an expection")
Pour obtenir de l'information sur l'erreur: accéder à l'instance de la classe Exception
concernée:
except Exception as e:
try:
print("test")
# generate an error: the variable test is not defined
print test
except Exception as e:
print("Caught an expection:", e)
import os
print(os.path.join('~', 'work', 'src'))
print(os.path.expanduser(os.path.join('~', 'work', 'src')))