Introduction à Python et au notebook IPython (Jupyter)

Bienvenue ! Ceci est un notebook IPython.

  • Un notebook est formé de cellules,
  • Chaque cellule contient du code (normalement, du Python),
  • En dessous de chaque cellule, son évaluation.
In [1]:
1 + 3
Out[1]:
4

IPython (Jupyter) est un système de présentation de documents scientifiques interactifs.

  • Il est conçu pour melanger discussion, presentation de données et calcul.
  • Une cellule peut aussi contenir autre chose que du Python...
In [2]:
%%html

<p>Cette cellule <strong>contient du HTML</strong> !</p>

<p>Remarquez la <em>clef magique</em> <code>%%html</code>.</p>

Cette cellule contient du HTML !

Remarquez la clef magique %%html.


Utiliser IPython

Avec IPython sont aussi installés

  • Le langage de programmation Python,
  • Le langage de programmation Julia,
  • Le système de statistiques R,
  • ...

...d'où Ju-Pyt-eR !

Le notebook est plus facile à utiliser si vous connaissez les raccourcis clavier. Echap, puis h pour les voir.


Syntaxe Python

Les variables Python n'ont pas de type déclaré, mais elles ont un type dynamique

In [3]:
a = 1
a
Out[3]:
1
In [4]:
type(a)
Out[4]:
int
In [5]:
a = "toto"
a
Out[5]:
'toto'
In [6]:
type(a)
Out[6]:
str

On ne combine pas deux types différents

In [7]:
a + 1
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-a1bd27f4633f> in <module>()
----> 1 a + 1

TypeError: cannot concatenate 'str' and 'int' objects

Python est orienté aux objets

Nous n'allons pas entrer dans les détails des langages orientés aux objets. En pratique,

  • Toute variable contient un objet,
  • Un objet possède des méthodes (des fonctions qui agissent sur l'objet).
In [8]:
a.upper()
Out[8]:
'TOTO'

Dans la majorité des cas, les méthodes ne modifient pas l'objet, mais en créent un nouveau

In [9]:
b = a.upper()
b
Out[9]:
'TOTO'
In [10]:
a
Out[10]:
'toto'

L'indentation et les retours à la ligne sont syntaxiques !

Vous n'avez pas droit de laisser de l'espace blanc à gauche du code sans raison

In [11]:
a = 1
 b = 2
  File "<ipython-input-11-12c30cde097b>", line 2
    b = 2
    ^
IndentationError: unexpected indent

Vous n'avez pas droit de couper une ligne

In [12]:
a = 
2
  File "<ipython-input-12-b737fa3c9036>", line 1
    a =
        ^
SyntaxError: invalid syntax

Types de données

Chaines de caractères

In [13]:
a = "toto"
In [14]:
a == 'toto'
Out[14]:
True

Il n'y a pas d'équivalent de char

In [15]:
a[1]
Out[15]:
'o'
In [16]:
type(a[1])
Out[16]:
str

Chaînes sur plusieurs lignes

In [17]:
a = "tot
o"
  File "<ipython-input-17-5c6c4e4b596f>", line 1
    a = "tot
           ^
SyntaxError: EOL while scanning string literal
In [18]:
a = """
Mignonne, allons voir si la rose
Qui ce matin avoit desclose
Sa robe de pourpre au Soleil,
"""
In [19]:
a
Out[19]:
'\nMignonne, allons voir si la rose\nQui ce matin avoit desclose\nSa robe de pourpre au Soleil,\n'

Instruction print pour afficher le texte

In [20]:
print a
Mignonne, allons voir si la rose
Qui ce matin avoit desclose
Sa robe de pourpre au Soleil,

Remplacement de valeurs (à la printf)

In [21]:
"La reponse est %d" % 42
Out[21]:
'La reponse est 42'
In [22]:
"La %s est %d" % ("question", 24)
Out[22]:
'La question est 24'

Nombres

In [23]:
a = 1
In [24]:
a == 1.0
Out[24]:
True

Les nombres ont précision arbitraire (pas d'overflow comme en C)

Le L à la fin indique un nombre long

In [25]:
a = 1000000
a * a * a * a * a * a
Out[25]:
1000000000000000000000000000000000000L

Opérateur puissance

In [26]:
a**6
Out[26]:
1000000000000000000000000000000000000L

Boléens

In [27]:
True == (not False)
Out[27]:
True
In [28]:
True and False
Out[28]:
False
In [29]:
True or False
Out[29]:
True

Listes

In [30]:
a = ["a", "b", "c"]
In [31]:
a[1]
Out[31]:
'b'
In [32]:
len(a)
Out[32]:
3
In [33]:
a[2] = "d"
a
Out[33]:
['a', 'b', 'd']
In [34]:
a[3]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-34-94e7916e7615> in <module>()
----> 1 a[3]

IndexError: list index out of range
In [35]:
a[3] = "e"
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-35-58c7bf901c62> in <module>()
----> 1 a[3] = "e"

IndexError: list assignment index out of range
In [36]:
a.append("e")
a
Out[36]:
['a', 'b', 'd', 'e']
In [37]:
" ~~=> ".join(a)
Out[37]:
'a ~~=> b ~~=> d ~~=> e'

Dictionnaires

In [38]:
a = { "couleur": "rouge", "forme": "rond"}
a
Out[38]:
{'couleur': 'rouge', 'forme': 'rond'}
In [39]:
len(a)
Out[39]:
2
In [40]:
a["couleur"]
Out[40]:
'rouge'
In [41]:
a["taille"] = "grand"
a
Out[41]:
{'couleur': 'rouge', 'forme': 'rond', 'taille': 'grand'}

Contrôle

L'indentation est importante !

Bloc if

In [42]:
if 1 + 1 == 2 and 1 - 1 > 0:
    a = 10
    print "faux"
elif 3 + 4 == 7:
    a = 3
    print "yes"
else:
    a = 4
    print "no"
    
a
yes
Out[42]:
3

Bloc while

In [43]:
i = 0
while i < 10:
    print i
    i += 1
0
1
2
3
4
5
6
7
8
9

Bloc for (très différent du C)

In [44]:
a = ["a", "b", "c"]

for x in a:
    print x
a
b
c

fonction range pour obtenir une liste de nombres

In [45]:
range(10)
Out[45]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [46]:
for i in range(10):
    print i
0
1
2
3
4
5
6
7
8
9

Fonctions

déclarées par le mot clef def

In [47]:
def ma_fonction(x, y):
    c = 2*x
    return c + y

ma_fonction(2, 3)
Out[47]:
7

Arguments par défaut

In [48]:
def fct(x, y=3, z=10):
    return x + y + z

fct(2), fct(2, 4), fct(2, 4, 1), fct(2, z=3)
Out[48]:
(15, 16, 7, 8)

Importer des fonctionnalités

In [49]:
import numpy
from pylab import imshow, show
from timeit import default_timer as timer

Et maintenant commence la fête !

In [51]:
%pylab inline

def mandel(x, y, max_iters):
  """
    Given the real and imaginary parts of a complex number,
    determine if it is a candidate for membership in the Mandelbrot
    set given a fixed number of iterations.
  """
  c = complex(x, y)
  z = 0.0j
  for i in range(max_iters):
    z = z*z + c
    if (z.real*z.real + z.imag*z.imag) >= 4:
      return i

  return max_iters



def create_fractal(min_x, max_x, min_y, max_y, image, iters):
  height = image.shape[0]
  width = image.shape[1]

  pixel_size_x = (max_x - min_x) / width
  pixel_size_y = (max_y - min_y) / height
    
  for x in range(width):
    real = min_x + x * pixel_size_x
    for y in range(height):
      imag = min_y + y * pixel_size_y
      color = mandel(real, imag, iters)
      image[y, x] = color

image = numpy.zeros((1024, 1536), dtype = numpy.uint8)
start = timer()
create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20) 
dt = timer() - start

print "Mandelbrot created in %f s" % dt
imshow(image)
show()
Populating the interactive namespace from numpy and matplotlib
Mandelbrot created in 8.127823 s
In [ ]: