In [ ]:
from __future__ import print_function
Les modules sont les portes d'accès aux bibliothèques de Python. Vous trouverez les références et les détails ici:
Pour utiliser un module, il faut l'importer avec la commande import. Voici un exemple pour importer le module math, qui définit les fonctions mathématiques classiques:
In [1]:
import math
Il est possible d'utiliser les fonctions du module math
tout de suite après, par exemple:
In [2]:
import math
x = math.cos(2 * math.pi)
print (x)
Après l'import, il faut préfixer toutes les méthodes et les objets, ce qui permet de lever des ambiguïtés à la lecture d'un code. Mais comme c'est contraignant, il est possible d'importer tout le module dans le namespace courant :
In [3]:
from math import *
x = cos(2 * pi)
print(x)
Pour concilier le meilleur des deux mondes, la bonne pratique recommandée est d'importer uniquement les méthodes nécessaires :
In [4]:
from math import cos, pi
x = cos(2 * pi)
print(x)
Si vous voulez émuler le comportement de Matlab, vous pouvez utiliser la commande import pylab, ce n'est plus maintenu dans les versions courantes de Python mais c'est encore possible de l'utiliser.
In [5]:
import pylab
Pour obtenir de l'aide en ligne avec IPython, vous pouvez taper un ? directement après l'objet, ou taper help(objet)
In [6]:
help(math.log)
In [7]:
math.exp?
Il est aussi possible de demander de l'aide sur un module, par exemple avec help(math).
In [8]:
help(math)
Les variables sont dynamiquement typées, pas besoin de préciser si c'est un entier ou un réel.
In [9]:
type(x)
Out[9]:
In [10]:
x = 1
type(x)
Out[10]:
Les chaînes de caractères sont bornées par des ' ' ou des " ". On peut connaître leur longueur avec len( ). On peut voir les méthodes associées en utilisant l'auto-complétion avec la touche tab.
In [13]:
s = u"une chaîne de caractères" # u'chaine' pour indiquer une chaîne en unicode
print ('taille de la chaine :',len(s))
s.replace?
s2 = s.replace('une', 'la')
print (s2)
La chaîne de caractère est un tableau, on accède aux éléments du tableau avec [ ]. Attention, pour les utilisateurs de MATLAB, en Python les tableaux commencent toujours à partir de 0. On peut utiliser la syntaxe complète [début:fin:incrément]
In [14]:
print (u'Le premier caractère est :'+ s[0])
In [16]:
print (u'Les 10 premiers caractères sont :'+s[:11])
In [17]:
print (u'Les caractères suivants sont :'+s[11:])
In [20]:
print (u'Le dernier caractère est :'+s[-1])
In [25]:
print (u'Avec un caractère sur deux :'+s[::2])
In [29]:
'mac' + 'hin' + 2*'truc'
Out[29]:
On peut arranger n'importe quel nombre d'éléments dans une liste.
In [30]:
l = ['oeufs', 'brouillés', 100, 1234]
print (type(l))
print ('la liste est :', l)
print ('le premier élément de la liste est:', l[0])
print ('Les 2 premiers éléments de la liste sont', l[0:2])
print ('Le dernier élément de la liste est', l[-1])
Une liste peut être modifiée, concatenée, découpée, etc.
In [31]:
l + ['bacon', 12345]
Out[31]:
In [32]:
3*l[:2]
Out[32]:
In [33]:
l[2] = l[2] + 23
print(l)
In [34]:
q = [2, 3]
p = [1, q, 4]
print ('La taille de la liste p est', len(p), "et c'est :", p)
print ('Le premier élément de la liste en 2e position est:', p[1][0])
In [35]:
l = list() # equivalent à l = []
l.append('p')
l.append('o')
l.append('t')
print (l)
l.sort()
print (l)
l.insert(0,'c')
l.insert(1,'o')
print (l)
l.remove('t')
print (l)
In [43]:
statement1 = False
statement2 = True
if statement1:
print("statement1 is True")
elif statement2:
print("statement2 is True")
else:
print("statement1 and statement2 are False")
if statement1 and statement2:
print ("statement1 and 2 are True")
if statement1 == statement2:
print ("statement1 and 2 are equal")
if statement1 != statement2:
print ("statement1 and 2 are not equal")
Le python utilise l'indentation pour déterminer la portée des contrôles; il n'y a pas d'accolades {} ni de parenthèses ().
In [45]:
statement1 = statement2 = True
if statement1:
if statement2:
print("both statement1 and statement2 are True") # attention aux indentations
Les boucles for utilisent une syntaxe simple:
In [46]:
for x in [1, 2, 3]:
print(x)
On a souvent recours à la fonction range([debut,]fin[,incrément]) dans les boucles. Attention, elle commence à zéro et finit avant fin. Par exemple, range(4) va de zéro à 3 mais n'inclut pas 4. La position des arguments de range est inspiré de la déclaration des itérateurs de boucles en C.
In [47]:
range(2, 10, 2)
Out[47]:
In [56]:
# for (i=0; i<10; i++) {...loop instructions...}
for x in range(10): # by default range start at 0
print(x, end=' ')
print()
for x in range(-4,5,2):
print(x, end=' ')
print()
for word in ["scientific", "computing", "with", "python"]:
print(word.capitalize(), end=' ')
print()
La fonction enumerate est parfois utile pour les boucles.
In [58]:
mes_notes = [15, 12, 8, 16, 13]
for i, note in enumerate(mes_notes):
print ('Note', i+1, ':', note)
for i in range(len(mes_notes)):
print ("Note", i+1, ':', mes_notes[i])
La boucle while ne présente pas de surprises:
In [59]:
i = 0
while i < 5:
print(i, end=' ')
i += 1
In [60]:
def func0():
print("test")
In [61]:
func0()
Il vaut mieux prendre les bonnes habitudes tout de suite et documenter les fonctions avec des docstrings, des chaînes de caractères situées juste après la définition de la fonction.
In [66]:
def longueur_de_chaine(s):
"""
func1, une fonction bien documentée
Affiche une string 's' et indique son nombre de caractères
"""
print(s + " a " + str(len(s)) + " caractères")
In [67]:
help(longueur_de_chaine)
longueur_de_chaine("azertyuiop")
In [68]:
longueur_de_chaine?
Une fonction peut retourner une ou plusieurs valeurs:
In [69]:
def carre(x):
"""
Retourne le carré de x.
"""
return x ** 2
def puissance(x):
"""
Retourne quelques puissances de x.
"""
return x ** 2, x ** 3, x ** 4
print ('Le carré de 3 est', carre(3))
x1 = carre(4)
print ("Le carré de 4 est", x1)
x2, x3, x4 = puissance(16)
print('Les premières puissances de 16 sont:', x2, x3, x4)
Il est possible de donner des arguments par défaut à une fonction:
In [71]:
def mafonc(x, p=2, debug=False):
"""
Calcule x à la puissance p. p vaut 2 par défaut.
debug active des affichages intermédiaires pour le debug
"""
if debug:
print("evaluation de mafonc pour x = " + str(x) +
" en utilisant comme exposant p = " + str(p))
return x**p
print ('Le résultat est :', mafonc(5, 2))
mafonc(5, debug=True)
mafonc(p=3, debug=False, x=7)
Out[71]:
Ce notebook est une adaptation de celui de J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/, ainsi que du tutoriel Python de Guido van Rossum & Fred Drake.