Ce que j'ai compris ou presque

Indentation

Mieux vaut en général un code écrit avec indentation que sans. En Python il n'y a pas de délimiteurs pour les boucles, tests, définition de fonctions, etc : c'est l'indentation qui a ce rôle

for i in range(0,10):
     print(i)

def f(x):
    y=x**2
    if (x>0):
        y=-x
    return y

Attention au copier/coller, en cas de mélange de la vraie tabulation et d'espaces il se peut que Python retourne un message d'erreur.

Variables immuables vs mutables

Il faut faire attention à certaines variables qui son immuables. Par exemple

In [5]: a=[1,2,4]

In [6]: b=a

In [7]: b.append(10), print(a)
[1, 2, 4, 10]
Out[7]: (None, None)

alors que

In [8]: a=3

In [9]: b=a

In [10]: b=10,  print(a)
3

Les entiers, flottants, chaînes de caractères sont immuables. Mais les listes, dictionnaires (et autres types définis dans des extensions) sont mutables.

Boucles, tests, etc

Boucle : range(0,10) de 0 à 9, range(5,-1,-1) boucle décroissante

Tests : if, elif, else et les booléens usuels

if x==3:
    print ("X vaut 3")
elif x==2:
    print ("X vaut 2")
else:
    print ("X ne vaut ni 2 ni 3")

x = 3
while x < 10:
   if x > 7:
      x += 3
      continue
   x = x + .5
   if x == 8:
      break
print("C'est terminé")

Fonctions

Pour définir une fonction (au sens large) : def

In [11]: def f(t,x):
   ....:      a=3
   ....:      return t*x, a*x**2
   ....: 

In [12]: y, z = f(1,2)

In [13]: print(y,z)
2 12

Fonctions et variable locale/globle

In [14]: def f(t,x):
   ....:      a=3
   ....:      return t*x, a*x**2
   ....: 

In [15]: def f2(t,x):
   ....:      global a
   ....:      a=3
   ....:      return t*x, a*x**2
   ....: 

In [16]: a=10

In [17]: f(1,2), print(a)
10
Out[17]: ((2, 12), None)

In [18]: f2(1,2), print(a)
3
Out[18]: ((2, 12), None)

Arithmétique approchée

Le flottant ne se comporte pas toujours comme il faut. Sans détailler la méthode de stockage des flottants, il faut en connaître quelques limites.

(A+B)+C peut être différent de A+(B+C) (idem avec *)

(A+B)-B peut être différent de A (idem avec * et /)

In [19]: x=0.001

In [20]: y=(1.0+x)-1.0

In [21]: print(x,y,x==y)
0.001 0.0009999999999998899 False

A+A+A peut être différent de 3.0*A

In [22]: x=1.0/6.0

In [23]: y= x+x+x+x+x+x

In [24]: print (y, y== 1.0)
0.9999999999999999 False

Arithmétique approchée (la suite)

B>0.0 n'entraîne pas toujours A+B>A

A>0.0 n'entraîne pas toujours 0.5*A>0.0

In [25]: x=1.0e-20

In [26]: y=5.0e-324

In [27]: print(1.0+x == 1.0, y/2.0)
True 0.0

Arithmétique approchée (suite et fin)

A>B et C>D n'entraîne pas toujours A+C>B+D

In [28]: a=.75+1.0e-16

In [29]: b=.75

In [30]: c=.5

In [31]: d=.5-1.0e-16

In [32]: print(a>b, c>d , a+c > b+d)
True True False

Il y a d'autres éléments comme la division par zéro, Nan, etc.

Extension

Sans extension, Python ne connaît même pas la fonction cosinus ! En effet tout le monde n'en a pas besoin, et un programme Python va aller chercher dans la bibliothèque standard selon il a besoin.

cos(1) # retourne une erreur
from math import cos
cos(1) # gagné !

On a le choix entre

from math import *
e(1), cos(2)

import math as mth
mth.e(1), mth.cos(2) # un peu lourd

3 ou 4 différences entre Python 2 et Python 3

La division

En Python 2.7.5 (un copier/coller)

In [2]: 4/3
Out[2]: 1

En Python 3.2.4 (version utilisée), on a un comportement similaire aux {Mat,Sci}lab

In [33]: 4/3
Out[33]: 1.3333333333333333

In [34]: 4//3
Out[34]: 1

La division du futur

Mais avec Python 2.7.5 on peut faire appel au futur

In [4]: from __future__ import division

In [5]: 4/3
Out[5]: 1.3333333333333333

La fonction print

En Python 2.7.5

In [13]: print "La valeur de Pi est", pi
La valeur de Pi est 3.14159265359

En Python 3.2.4, parenthèses et deux options supplémentaires

In [35]: from math import pi

In [36]: print ("La valeur de Pi est", pi)
La valeur de Pi est 3.141592653589793

In [37]: print ("La valeur de Pi est", pi, sep='%', end='#')
La valeur de Pi est%3.141592653589793#

range et liste

En Python 2.7.5, range retourne une liste

In [14]: type(range(10))
Out[14]: list

En Python 3.2.4, range retourne la classe 'range' (itération)

In [38]: type(range(10))
Out[38]: builtins.range

In [39]: print(range(7))
range(0, 7)

In [40]: print(list(range(7)))
[0, 1, 2, 3, 4, 5, 6]

D'autres fonctions ont vécu ces mêmes modifications.

Encodage

En Python 2.7, utiliser l'encodage Unicode (utf8) nécessite quelques précaution : l'exécution du script suivant donne une erreur

#!/usr/bin/env python
u = 'Lycée'
print u

Il faut préciser le codage du fichier à Python et mieux vaut spécifier que la chaîne de caractère est en utf8 via u"Lycée".

#!/usr/bin/env python
# -*- coding: utf-8 -*-
u = u'Lycée'
print u

Encodage

En Python3, l'unicode est de rigueur

#!/usr/bin/env python
u = 'Lycée'
print (u)

Numpy

Numpy est la base utilisée par d'autres extensions de calcul

Matplotlib

Imite la syntaxe de Matlab (comme Scilab depuis quelques années)

Scipy

Le complément de Numpy

Importation des extensions

En mode interactif on peut se permettre de faire

from numpy import *
import matplotlib.pyplot as plt

Dans les programmes il est conseillé d'écrire

import numpy as np
import matplotlib.pyplot as plt

Ainsi toutes les commandes de Numpy seront np.{la suite} et pour Matplotlib (tracé 2D) plt.{la suite}

Ipython --pylab

Pour une utilisation interactive Ipython possède un mode "Pylab", ipython --pylab qui charge automatiquement Matplotlib et Numpy.

In [43]: import numpy.random

In [44]: hist(np.random.randn(10000), 100);
_images/hist_simple.png