Introduction pas à pas de Python

Ce notebook constitue une rapide introduction à Python. Le langage est découvert en exécutant un grand nombre de simples et courtes lignes de code. L’objectif est d’entrapercevoir la manière dont Python fonctionne afin d’éviter de tomber dans les pièges classiques des débutants.

Cette approche est inspirée des tutoriels Python by immersion et Python Epiphanies créés par Stuart Williams.

Indentation

---

Tout est dans le style

---

Python a été conçu de manière à être facile à lire, partant du principe qu’on passe plus de temps à lire du code qu’à en écrire. Cela se matérialise par l’importance de l”indentation (décalage d’une ligne de code vers la droite). L’indentation du code détermine en partie sa structure. Dans l’exemple ci-dessous, les deux instructions print sont situées au même niveau d’indentation.

print("Hey")
print("you")

Hey
you

Le code est exécuté normalement. La deuxième instruction du code suivant a été décalée de deux espaces, le code ne peut tout simplement plus être exécuté car cette structure n’a aucun sens pour Python.

print("Hey")
  print("you")

  File "<ipython-input-683-a6cbeba02af8>", line 2
    print("you")
    ^
IndentationError: unexpected indent

L’utilité de l’indentation est plus évidente dans le cas de blocs logiques, tel qu’un bloc for. Le code ci-dessous s’exécute correctement.

for i in [1, 2, 3]:
    print(i)  # L'indentation est de 4 espaces en général.

1
2
3

Alors que le code ci-dessous ne peut pas être exécuté, les instructions sous la ligne for n’étant pas indentées. Comme on peut le voir, c’est le code du dessus qui est le plus facile à lire, l’indentation nous aide à comprendre la structure logique du code.

for i in [1, 2, 3]:
print(i)

  File "<ipython-input-685-3e96090b8527>", line 2
    print(i)
        ^
IndentationError: expected an indented block

Afin de définir les boucles et autres structures de contrôle, d’autres langages utilisent des symbôles ({}, ()). En choisissant d’utiliser l’indentation au lieu de symboles, Python a faix le choix du code épuré.

Commentaires et pass

---

Fainéant

---

Les commentaires sont des lignes qui débutent par un signe #. Ces lignes-là sont ignorées par l’interpréteur.

# Ceci est un commentaire.

# On
# peut
# les
# enchaîner

###### Ceci aussi est un commentaire.

On peut rajouter un commentaire à la suite d’un code valide (séparé de deux espaces par convention).

3.14  # Ceci est aussi un commentaire.

3.14

Le *keyword* **pass** fait comme son nom l'indique, il passe son tour.

  File "<ipython-input-1-4bc46cd563cf>", line 1
    Le *keyword* **pass** fait comme son nom l'indique, il passe son tour.
                  ^
SyntaxError: invalid syntax

pass

Objets

---

Tout est un objet!

---

Exécuter les instructions simples ci-dessous peut faire penser que Python ne fait rien de plus qu’une simple calculette.

3.4

3.4

3.4 + 4

7.4

Pourtant, beaucoup de choses se passent!

dir(3.4)

['__abs__',
 '__add__',
 '__bool__',
 '__class__',
 '__delattr__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getformat__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__int__',
 '__le__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rmod__',
 '__rmul__',
 '__round__',
 '__rpow__',
 '__rsub__',
 '__rtruediv__',
 '__set_format__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__trunc__',
 'as_integer_ratio',
 'conjugate',
 'fromhex',
 'hex',
 'imag',
 'is_integer',
 'real']

La fonction dir retourne une liste de tous les attributs d’un objet. La liste ci-dessus montre donc tous les attributs de l’objet 3.4. Les derniers attributs affichés, dont is_integer, nous indiquent que Python a compris que 3.4 est un nombre. On peut le vérifier en inspectant la valeur de l’attribut __class__. Pour accéder à la valeur d’un attribut, on rajout un point ``.`` après l’objet suivi du nom de l’attribut.

3.4.__class__

float

float est un type d’objet qui représente les nombres réels. Mais plutôt que de vérifier le type d’un objet en accédant à son attribut *__class__*, on peut utiliser la fonction type. Cette fonction, comme dir, fait partie des fonctions dites built-in car faisant parties intégrantes de Python (il n’y a pas besoin d’importer quoi que ce soit pour les appeler). On va voir plusieurs de ces fonctions dans la suite du notebook.

type(3.4)

float

On a donc vu que lorsqu’on exécute 3.4, Python ne fait pas juste qu’afficher ce nombre mais l’interprète comme un objet de type float doté de nombreux attributs. Que se passe-t-il alors lorsqu’on exécute 3.4 + 4?

3.4.__add__(4)

7.4

L’addition que nous avons écrite est en fait exécutée par l’instruction ci-dessus. Python voit que nous avons écrit un + après 3.4, il cherche alors l’attribut dunder (racourci de double underscore donné aux attributs qui débutent et terminent par __) __add__ dans la liste des attributs de 3.4. L’attribut __add__ des floats est en fait une méthode qui est capable de faire une action, dans ce cas-là, une addition. Lorsque Python trouve l’attribut __add__ de 3.4, il l’appelle avec l”argument 4. La valeur retournée est le résultat de l’addition.

Python n’est donc évidemment pas qu’une simple calculatrice. Lorsqu’il évalue les expressions qu’on lui donne, il crée des objets dotés d’un type et d’attributs. Ces attributs sont soit équivalent à des propriétés, comme __class__, soit des méthodes, comme __add__. Cette mécanique est présente partout dans le langage, celui-ci travaille en effet beaucoup pour nous. Il faut aussi noter que Python s’occupe d’allouer et libérer la mémoire à notre place.

type(3.4.__add__)

method-wrapper

Chaque objet créé a sa propre identité définie comme son adresse physique dans la mémoire.

id(3.4)

1921982076992

id(3.4)

1921982076896

id(4)

140734432777120

dir et id sont des fonctions qu’on n’utilise presque jamais dans un script mais qui sont très utiles pour apprendre Python et inspecter des objets.

type(dir)

builtin_function_or_method

type(id)

builtin_function_or_method

Une fonction est aussi un objet (tout est un objet!) avec ses propres attributs, un type et une identité.

dir(dir)

['__call__',
 '__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__name__',
 '__ne__',
 '__new__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__self__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__text_signature__']

id(dir)

1921920700776

id(dir)

1921920700776

Erreurs

---

Antifragilité

---

Lorsqu’on écrit du code en Python et qu’on l’exécute pour la première fois, il est habituel de voir un message d’erreur apparaître. Ces erreurs nous indiquent ce qui ne fonctionne pas dans le code, et nous oriente pour résoudre le bug qui a causé l’erreur. Python dispose d’un grand nombre de genres d’erreur, à force de les déclencher on s’habitue à les reconnaître et on comprend de plus en plus rapidement d’où vient le problème.

type(1)
 type(2)  # L'espace déclenche l'erreur

  File "<ipython-input-702-f456bc8300ff>", line 2
    type(2)  # L'espace déclenche l'erreur
    ^
IndentationError: unexpected indent

1
3 +)°^ 3  # Cette suite de symboles n'a aucun sens

  File "<ipython-input-703-57174e9a2a28>", line 2
    3 +)°^ 3  # Cette suite de symboles n'a aucun sens
       ^
SyntaxError: invalid syntax

Les erreurs IntendationError et SyntaxError nous indique que le code n’a pas été écrit correctement. L’interpréteur analyse tout le code qu’on a écrit, s’il détecte ce genre d’erreur, il nous l’indique et n’exécute aucune ligne de code. Toutes les autres erreurs qu’on peut avoir surviennent pendant l’exécution du code (runtime).

print et help

---

Pour y voir plus clair

---

print affiche les objets passés à la fonction. help affiche l’aide d’un objet.

print(3.4, 4, 5, 1, 0)

3.4 4 5 1 0

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

On va beaucoup utiliser la fonction print. Le début de sa définition est print(value, ..., sep=' '):

• value, ...: print accepte un nombre illimité d’arguments séparés par une virgule

print(3.4, 4, 6, 103, 3030, 0, 0)

3.4 4 6 103 3030 0 0

• sep=' ': l’espacement par défaut entre deux valeurs affichées par print est un espace, on peut le changer en spécifiant le paramètre sep

print(3.4, 4, 6, 103, 3030, 0, 0, sep="  :)   ")

3.4  :)   4  :)   6  :)   103  :)   3030  :)   0  :)   0

# "\n" est interprété comme un retour à la ligne
print(3.4, 4, 6, 103, 3030, 0, 0, sep="\n")

3.4
4
6
103
3030
0
0

Nommer

---

Poser des post-its par-ci, par-là

---

Jusqu’à présent les objets qui ont été utilisés sont supprimés aussitôt générés par Python. On peut les garder à notre disposition en leur assignant un nom.

height = 1.73

height

1.73

type(height)

float

id(height)

1921982077232

id(height)

1921982077232

print(height, height, height)

1.73 1.73 1.73

Regardez bien les trois instructions ci-dessous, quelle est la valeur finale de ``x``?

x = 2
y = x
y = 4

print(x, y)

2 4

On aurait pu croire que x valait 4 à la fin des trois instructions, mais non. Les noms en Python sont juste des références aux objets, on peut les comparer à des post-its.

x = 2
# L'objet 2 est créé, un post-it avec inscrit *x* lui est aposé.
print("x =", x, " / id(x):", id(x))
y = x
# Un second post-it est aposé sur l'objet 2, il y est inscrit *y*.
print("x =", x, " / id(x):", id(x), "  ---  y =", y, " / id(y):", id(y))
# Aucun objet n'est créé lors de cette instruction.
y = 4
# L'objet 4 est créé, comme un nom ne peut référé qu'à un seul objet
# le post-it *y* qui était sur l'objet 2 est supprimé et un nouveau
# post-it *y* est aposé sur l'objet 4.
print("x =", x, " / id(x):", id(x), "  ---  y =", y, " / id(y):", id(y))

x = 2  / id(x): 140734432777056
x = 2  / id(x): 140734432777056   ---  y = 2  / id(y): 140734432777056
x = 2  / id(x): 140734432777056   ---  y = 4  / id(y): 140734432777120

Une fois que des références aux objets ont été créées, celles-ci sont rajoutées au namespace. On peut les références qu’on a nous-mêmes rajoutées au namespace avec la commande magique whos.

%whos

Variable   Type     Data/Info
-----------------------------
height     float    1.73
i          int      3
x          int      2
y          int      4

Ainsi, lorsqu’on l’on fait référence à un objet par un de ses noms, Python cherche dans le namespace la référence de cet objet et utilise la donnée qui lui est associée.

height

1.73

poids

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-721-adb260374773> in <module>
----> 1 poids

NameError: name 'poids' is not defined

Comme poids n’est pas une référence du namespace (on peut aussi dire que la variable poids n’a pas encore été définie), l’interpréteur retourne une erreur.

On peut déréférencer un élément du namespace avec une instruction utilisant le keyword del.

# On enlève le post-it *height* de l'objet 1.73,
# celui-ci n'est plus accessible à la suite de ça.
del height

%whos

Variable   Type    Data/Info
----------------------------
i          int     3
x          int     2
y          int     4

del height

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-724-f8c467be9fdb> in <module>
----> 1 del height

NameError: name 'height' is not defined

height

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-725-5107fc8585e9> in <module>
----> 1 height

NameError: name 'height' is not defined

On peut déférencer tous les éléments du namespace avec la commande magique %reset -f.

%reset -f

%whos

Interactive namespace is empty.

Keywords

---

Un peu de liant

---

Avec l’indentation, les keywords structurent le langage. On utilisera principalement les suivants:

• Le vide: None
• Booléens: True, False
• Opérations booléennes: and, or, not
• Appartenance: in, not in
• Identification: is, is not
• Boucles: for, while break, continue, pass,
• Conditions: if, elif, else
• Fonctions: def, return
• Import: import, from, as
• Déférencement: del
• Pas d’action: pass

help("keywords")

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not

Les keywords sont des mots réservés, aucun objet ne peut avoir un nom qui fait partie des keywords.

True = 2

  File "<ipython-input-730-da3e5402d318>", line 1
    True = 2
            ^
SyntaxError: can't assign to keyword

true = 2  # On peut faire ça, mais c'est maladroit!

help("for")

The "for" statement
*******************

The "for" statement is used to iterate over the elements of a sequence
(such as a string, tuple or list) or other iterable object:

   for_stmt ::= "for" target_list "in" expression_list ":" suite
                ["else" ":" suite]

The expression list is evaluated once; it should yield an iterable
object.  An iterator is created for the result of the
"expression_list".  The suite is then executed once for each item
provided by the iterator, in the order returned by the iterator.  Each
item in turn is assigned to the target list using the standard rules
for assignments (see Assignment statements), and then the suite is
executed.  When the items are exhausted (which is immediately when the
sequence is empty or an iterator raises a "StopIteration" exception),
the suite in the "else" clause, if present, is executed, and the loop
terminates.

A "break" statement executed in the first suite terminates the loop
without executing the "else" clause’s suite.  A "continue" statement
executed in the first suite skips the rest of the suite and continues
with the next item, or with the "else" clause if there is no next
item.

The for-loop makes assignments to the variables(s) in the target list.
This overwrites all previous assignments to those variables including
those made in the suite of the for-loop:

   for i in range(10):
       print(i)
       i = 5             # this will not affect the for-loop
                         # because i will be overwritten with the next
                         # index in the range

Names in the target list are not deleted when the loop is finished,
but if the sequence is empty, they will not have been assigned to at
all by the loop.  Hint: the built-in function "range()" returns an
iterator of integers suitable to emulate the effect of Pascal’s "for i
:= a to b do"; e.g., "list(range(3))" returns the list "[0, 1, 2]".

Note: There is a subtlety when the sequence is being modified by the
  loop (this can only occur for mutable sequences, e.g. lists).  An
  internal counter is used to keep track of which item is used next,
  and this is incremented on each iteration.  When this counter has
  reached the length of the sequence the loop terminates.  This means
  that if the suite deletes the current (or a previous) item from the
  sequence, the next item will be skipped (since it gets the index of
  the current item which has already been treated).  Likewise, if the
  suite inserts an item in the sequence before the current item, the
  current item will be treated again the next time through the loop.
  This can lead to nasty bugs that can be avoided by making a
  temporary copy using a slice of the whole sequence, e.g.,

     for x in a[:]:
         if x < 0: a.remove(x)

Related help topics: break, continue, while

A part True, False et None, les keywords ne sont pas des objets.

Opérateurs principaux

---

Pas que pour les maths!

---

3.4 + 4

7.4

3.4 - 4

-0.6000000000000001

3.4 * 4

13.6

3.4 / 4

0.85

11 // 4

2

(11).__floordiv__(4)

2

11 % 4

3

(11 // 4) * 4 + (11 % 4)

11

11 // 4 * 4 + 11 % 4  # Moins facile à lire

11

3.4 > 4

False

3.4 < 4

True

3.4 <= 4

True

3.4 >= 4

False

2 < 5 < 10

True

3 > 2 >= 10

False

3.4 == 4

False

3.4 != 4

True

4 == 4

True

Importer

---

Batteries included

---

Nous avons pour l’instant vu que nous avions à disposition des fonctions built-in, des keywords et des opérateurs. Un mécanisme permet d”importer des objets supplémentaires dans le code, comme des fonctions.

import math

math est un module de la standard library. La standard library est une grande collection de modules livrés avec Python, c’est pourquoi on associe souvent l’expression Batteries Included au langage.

%whos

Variable   Type      Data/Info
------------------------------
math       module    <module 'math' (built-in)>
true       int       2

math est le module dédié aux opérations mathématiques. En exécutant import math, on a rajouté au namespace le nom math, celui-ci faisant référence à un objet de type module.

print(dir(math))

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

On peut voir que le module contient les attributs sqrt (racine carrée) et pi. On accède à ces attributs en rajoutant un . après math.

math.sqrt

<function math.sqrt(x, /)>

math.pi

3.141592653589793

type(math.sqrt)

builtin_function_or_method

type(math.pi)

float

math.sqrt(math.pi)

1.7724538509055159

import math as m importe le module math avec pour référence m et non math. Cette méthode peut être utilisé lorsque le nom du module est très long, ou si ce nom va être répété à de très nombreuses reprises. Trois examples classiques étant import numpy as np, import pandas as pd, import matplotlib.pyplot as plt.

%reset -f

import math as m

math

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-763-a984292e3e46> in <module>
----> 1 math

NameError: name 'math' is not defined

m

<module 'math' (built-in)>

%whos

Variable   Type      Data/Info
------------------------------
m          module    <module 'math' (built-in)>

m.sqrt(m.pi)

1.7724538509055159

%reset -f

Modules et packages

---

Batteries included in batteries

---

Les modules sont matérialisés par des fichiers textes dont l’extension est ``.py``. Lorsqu’on importe un module, le code qu’il contient est exécuté. Les objets qui sont créés dans ce module sont donc accessibles.

%%writefile dummymodule.py
"""Un tout petit module."""
print("hello world")
x = 2

Overwriting dummymodule.py

import dummymodule

dummymodule.x

2

print(dir(dummymodule))

['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'x']

dummymodule.__doc__

'Un tout petit module.'

help(dummymodule)

Help on module dummymodule:

NAME
    dummymodule - Un tout petit module.

DATA
    x = 2

FILE
    d:\googledrive\code\intropython\source\dummymodule.py

Lorsqu’il tente d’importer quelque chose, Python cherche dans une liste de dossier qu’on retrouve dans la référence sys.path. Cette liste contient le dossier courant.

import sys
sys.path

['D:\\GoogleDrive\\Code\\IntroPython\\source',
 'C:\\Users\\maxim\\Miniconda3\\python37.zip',
 'C:\\Users\\maxim\\Miniconda3\\DLLs',
 'C:\\Users\\maxim\\Miniconda3\\lib',
 'C:\\Users\\maxim\\Miniconda3',
 '',
 'C:\\Users\\maxim\\AppData\\Roaming\\Python\\Python37\\site-packages',
 'C:\\Users\\maxim\\Miniconda3\\lib\\site-packages',
 'C:\\Users\\maxim\\Miniconda3\\lib\\site-packages\\win32',
 'C:\\Users\\maxim\\Miniconda3\\lib\\site-packages\\win32\\lib',
 'C:\\Users\\maxim\\Miniconda3\\lib\\site-packages\\Pythonwin',
 'C:\\Users\\maxim\\Miniconda3\\lib\\site-packages\\IPython\\extensions',
 'C:\\Users\\maxim\\.ipython']

Les modules de la standard library écrits en Python (il y a aussi des modules écrits en C) sont visibles sur GitHub. Dans ce dossier on trouve aussi des sous-dossiers qui contiennent des fichiers .py et un fichier __init__.py. Ces dossiers-là sont des packages qu’on peut aussi importer.

import email

email.__package__

'email'

email.__path__

['C:\\Users\\maxim\\Miniconda3\\lib\\email']

email.__file__

'C:\\Users\\maxim\\Miniconda3\\lib\\email\\__init__.py'

import email.mime

dir(email.mime)

['__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__path__',
 '__spec__',
 'audio',
 'base',
 'nonmultipart']

email.mime.__package__

'email.mime'

import email.mime.audio as audio

type(audio)

module

audio.__file__

'C:\\Users\\maxim\\Miniconda3\\lib\\email\\mime\\audio.py'

Voici une très courte liste de modules utiles.

import sys
sys.executable

'C:\\Users\\maxim\\Miniconda3\\python.exe'

sys.version

'3.7.3 (default, Apr 24 2019, 15:29:51) [MSC v.1915 64 bit (AMD64)]'

import time
t1 = time.time()
time.sleep(2)
t2 = time.time()
print(t2 - t1)

2.0007686614990234

import datetime
guess = datetime.datetime(2019, 9, 10, 10, 10, 30)
now = datetime.datetime.now()
diff = now - guess
print("Je me suis trompé de", diff.seconds, "secondes.")

Je me suis trompé de 2415 secondes.

import random
random.random()

0.4721376731418996

random.randint(10, 20)

15

random.choice(["a", "b", "c"])

'b'

random.sample([1, 2, 3, 4], 3)

[2, 3, 1]

random.gauss(10, 3)

10.973576155873744

import pathlib
current_directory = pathlib.Path.cwd()
current_directory

WindowsPath('D:/GoogleDrive/Code/IntroPython/source')

list(current_directory.glob("*"))

[WindowsPath('D:/GoogleDrive/Code/IntroPython/source/.ipynb_checkpoints'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/conf.py'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/dummymodule.py'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/environnement.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/exercices.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/images'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/index.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/installation.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/introduction.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/intropython.ipynb'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/intropython_extended.ipynb'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/python.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/scientific_libs.ipynb'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/utilisation.rst'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/_static'),
 WindowsPath('D:/GoogleDrive/Code/IntroPython/source/__pycache__')]

import collections
collections.Counter("aaabbbbbbbbbbbbbcccddddee").most_common()

[('b', 13), ('d', 4), ('a', 3), ('c', 3), ('e', 2)]

%reset -f
!del /f dummymodule.py

Conditions if et booléens

---

Avec des si

---

Le bloc sous une instruction if est exécuté entièrement si la condition (expression) qui suit le if est évaluée comme vraie.

if True:
    print("Executed")

Executed

if False:
    print("Not executed")

On peut rajouter d’autres conditions avec les keywords elif et else.

age = 27
if age < 18:
    print("Sorry you're not allowed to drive.")
elif 18 <= age < 80:
    print("Let's drive!")
elif 80 <= age < 122:
    print("Please please please strop driving please!")
else:
    print("Is that you Jeanne?")

Let's drive!

On peut assigner le résultat d’un comparaison à une référence et on peut combiner plusieurs comparaisons avec les keywords and et or.

condition1 = 18 <= 10 < 80
condition2 = 18 <= 54 < 80
condition1 and condition2

False

True and True

True

True or True

True

False and False

False

False or False

False

False and True

False

False or True

True

True et False sont des booléens.

print(type(condition1), type(condition2))

<class 'bool'> <class 'bool'>

%reset -f

Texte

---

Du blabla

---

Le texte est représenté par des objets de type string. On encadre le texte des symboles " ou ' ou """ ou ''' pour créer un objet string.

"Bob"

'Bob'

'Bob'

'Bob'

"""Bob"""

'Bob'

'''Bob'''

'Bob'

type("Bob")

str

print("'")

'

print('"')

"

On peut les additionner et les démultiplitier.

"Bob" + "Bill"

'BobBill'

"Bob" * 3

'BobBobBob'

3 * "Bob"

'BobBobBob'

"Bob" - "Bill"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-837-a8c1ff178148> in <module>
----> 1 "Bob" - "Bill"

TypeError: unsupported operand type(s) for -: 'str' and 'str'

"Bob" / 3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-838-f7f9e058c01b> in <module>
----> 1 "Bob" / 3

TypeError: unsupported operand type(s) for /: 'str' and 'int'

Il est possible de créer une string vide.

""

''

"Bob" + "" + "Bill"

'BobBill'

Le caractère backslash ```` déclenche un comportement spécial: l’interpréteur regarde le caractère qui suit et voit si la combinaison des deux caractères forme ou non un caractère spécial, si oui, celui-ci est représenté.

# \n --> Retour à la ligne
# \t --> Tabulation

print("Bob\tBill\nBill\tBob")

Bob     Bill
Bill    Bob

Le caractère \ a donc un effet particulier. Cela rend plus difficile la représentation d’un chemin vers un dossier ou un fichier sous Windows. On annule l’effet particulier de \ en rajoutant le préfixe r (pour raw) devant le premier guillemet de la string.

print(r"user\me\names.txt")  # OK

user\me\names.txt

print("user\me\names.txt")  # not OK

user\me
ames.txt

On peut vérifier si deux strings sont égales avec l”opérateur égalité ==. Pour vérifier si une partie d’une string se trouve dans une autre, on utilise le keyword in.

"Bob" == "Bill"

False

"Bob" != "Bill"

True

"Bill" in "Bob and Bill"

True

"John" in "Bob and Bill"

False

"Bill" not in "Bob and Bill"

False

Les strings possèdent beaucoup de méthodes pour les analyser et transformer. Lorsqu’une méthode a pour objectif de transformer une string elle retourne un nouvel objet string qui est version transformée de la string initiale. Elles ne le modifient pas directement l’objet initial. En effet, les ``strings`` sont des objets immutables.

name = "bob"
print(dir(name))

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

name.upper()

'BOB'

name

'bob'

name.title()

'Bob'

name.replace("o", "a")

'bab'

txt = "   espaces avant et espaces après      "
txt.strip()

'espaces avant et espaces après'

strip enlève par défaut les espaces au début et à la fin de la string. Les espaces comprennent les sauts de ligne et les tabulations.

sentence = "quel beau temps"
words = sentence.split()
words

['quel', 'beau', 'temps']

sentence.split("l")

['que', ' beau temps']

" ".join(words)

'quel beau temps'

On peut enchaîner les méthodes tant qu’on fait attention à ce que la méthode qui suit accepte est bien une méthode de l’objet retourné par la méthode qui précède. Dans l’exemple ci-dessous, la méthode strip est bien un méthode de l’objet sentence qui est de type string, elle retourne un objet string qui possède bien une méthode replace, celle-ci retourne un nouvel objet string qui possède bien une méthode split, celle-ci retourne finalement une liste.

modified_sentence = sentence.strip("qs").replace("e", "i").split()
modified_sentence

['uil', 'biau', 'timp']

%reset -f

F-String

---

Du joli blabla

---

Les f-strings sont des objets de type string qu’on peut formater. Il faut rajouter un préfixe f devant le premier guillemet, puis ensuite, à l’intérieur, il faut entourer de symboles {} les expressions qu’on souhaite formater afin qu’elles soient directement évaluées par Python, qui construit notre objet string.

age = 28
f"J'ai {age} ans"

"J'ai 28 ans"

type(age)

int

"J'ai " + age + " ans"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-866-1c648e4e0b43> in <module>
----> 1 "J'ai " + age + " ans"

TypeError: can only concatenate str (not "int") to str

age = 28
majorite = 18
if age > majorite:
    print(f"Tu as {age - majorite} ans de plus que la majorité qui est à {majorite} ans.")

Tu as 10 ans de plus que la majorité qui est à 18 ans.

Cette manière de formater les strings est assez récente (Python 3.6) et est vraiment pratique et facile à utiliser. Il existe deux autres manières de formater des strings qu’on retrouve encore souvent sur internet.

%reset -f

Convertir float, int et str

---

Nombre <—> Texte <—> Nombre

---

Les fonctions int, float et str tentent de convertir les objets qu’on leur donne. Elles retournent une erreur ``ValueError`` si elles échouent, et l’objet converti si elles réussissent.

int(3.7)

3

float(4)

4.0

str(3)

'3'

int("Bob")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-874-b70fd5693779> in <module>
----> 1 int("Bob")

ValueError: invalid literal for int() with base 10: 'Bob'

x = "3"
print(type(x))
x = int(x)
print(type(x))

<class 'str'>
<class 'int'>

"Bob" + 3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-876-45c29619c55a> in <module>
----> 1 "Bob" + 3

TypeError: can only concatenate str (not "int") to str

"Bob " + str(3)

'Bob 3'

# print convertit automatiquement les objets en string.
print("Bob", 3)

Bob 3

%reset -f

Indexing et Slicing

---

A piece of cake

---

Certains objets comme les objets de type string sont des séquences. On peut obtenir n’importe quel item de l’objet grâce à son index numérique (indexing), on peut aussi obtenir directement plusieurs items (slicing). Le premier item d’une séquence a toujours l’index 0 en Python (0-based).

txt = "John"

txt[0]

'J'

txt[1]

'o'

txt[2]

'h'

txt[3]

'n'

txt[4]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-885-e9d47c8188c4> in <module>
----> 1 txt[4]

IndexError: string index out of range

L’index -1 est un raccourci pour indiquer le dernier caractère. -2 indique l’avant-dernier caractère, etc.

txt[-1]

'n'

txt[-2]

'h'

txt[-3]

'o'

txt[-4]

'J'

txt[-5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-890-e5b69442cb73> in <module>
----> 1 txt[-5]

IndexError: string index out of range

On peut connaître le nombre d’items d’une séquence avec la fonction ``len``. Lorsqu’on passe un objet string à la fonction len, on obtient le nombre de caractères de l’objet.

len(txt)

4

len("")

0

len(" ")

1

Attention au comportement spécial du backslash \.

len("\n")

1

len(r"\n")

2

len("Bob and Bill")

12

len(3.4)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-898-a9f429718b04> in <module>
----> 1 len(3.4)

TypeError: object of type 'float' has no len()

On ne peut pas modifier un item d’une string à partir de son index. En fait, il est simplement impossible de modifier un objet string, il faut forcément en créer un nouveau. Un objet qui ne peut pas être modifié est dit immutable.

txt[0] = "A"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-899-dc27665d30a4> in <module>
----> 1 txt[0] = "A"

TypeError: 'str' object does not support item assignment

Pour obtenir plusieurs caractères d’un objet string, on utilise la syntaxe [start:stop:step] où start et stop sont des index, et step l’écart entre deux caractères. Par défaut, start est le premier index ([0]), stop est le dernier index, et step est égal à 1. L’élément à l’index ``start`` est inclus dans l’objet string retourné, l’élément à l’index ``stop`` est exclus.

numbers = "0123456789"
numbers[3::]

'3456789'

numbers[3:]

'3456789'

numbers[50::]

''

numbers[:8]

'01234567'

numbers[3:8]

'34567'

numbers[3:3]

''

numbers[3:50]

'3456789'

numbers[::2]

'02468'

La syntaxe ::-1 permet d’inverser la list originale.

numbers[::-1]

'9876543210'

numbers[::-2]

'97531'

numbers[3:8:3]

'36'

numbers[3:8:-1]

''

numbers[8:3]

''

numbers[8:3:-1]

'87654'

%reset -f

Listes et Tuples

---

Maîtres de l’ordre

---

Les objets de type list et tuple sont des containers. Ces deux types d’objet sont, comme les objets de type string, des séquences. Ils peuvent contenir n’importe quel type d’objet.

Les lists et les tuples sont très pratiques et utilisés partout dans le langage Python.

shopping = ["banana", "beer", "chocolate", "tomato", "salad"]

type(shopping)

list

print(dir(list))

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

L’objet retourné par la fonction dir est une list.

type(dir(list))

list

On peut accéder à chaque item d’une list par son index numérique.

shopping[0]

'banana'

shopping[-1]

'salad'

shopping[1:4:2]

['beer', 'tomato']

shopping[::-1]

['salad', 'tomato', 'chocolate', 'beer', 'banana']

len(shopping)

5

len([])

0

Alors qu’on définit une list en entourant ses items de [], on définit un tuple en entourant ses items de ().

shopping = ("banana", "beer", "chocolate", "tomato", "salad")

type(shopping)

tuple

On accède aux items d’un tuple comme on accède aux items d’une list.

shopping[0]

'banana'

shopping[-1]

'salad'

shopping[1:4:2]

('beer', 'tomato')

shopping[::-1]

('salad', 'tomato', 'chocolate', 'beer', 'banana')

len(shopping)

5

len(())

0

Une list ou dans un tuple peuvent faire référence à n’importe quel type d’objet.

import math
big_mess = [2, 2.33, "string", print, math, ["Bob", "Bill"]]
big_mess

[2,
 2.33,
 'string',
 <function print>,
 <module 'math' (built-in)>,
 ['Bob', 'Bill']]

import math
big_mess = (2, 2.33, "string", print, math, ["Bob", "Bill"])
big_mess

(2,
 2.33,
 'string',
 <function print>,
 <module 'math' (built-in)>,
 ['Bob', 'Bill'])

Les ``lists`` et les ``tuples`` ne contiennent aucun objet, ils contiennent en fait des références à d’autres objets.

pi = 3.14

l = [pi]

# l'objet `3.14` a deux post-its posés sur lui: `pi` et `l[0]`.
print(f"""\
{'ID de l:':15}{id(l)}
{'ID de pi:':15}{id(pi)}
{'ID de l[0]:':15}{id(l[0])}""")

ID de l:       1921982303368
ID de pi:      1921965186936
ID de l[0]:    1921965186936

Comme les strings, les tuples sont des immutables.

shopping[0] = 55

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-944-7be9fb42ab76> in <module>
----> 1 shopping[0] = 55

TypeError: 'tuple' object does not support item assignment

Au contraire, les lists sont des mutables. Il est donc autorisé de remplacer ou supprimer les éléments qu’elles contiennent, ou d’en rajouter.

shopping = ["banana", "beer", "chocolate", "tomato", "salad"]
print(id(shopping), shopping)

1921962349576 ['banana', 'beer', 'chocolate', 'tomato', 'salad']

shopping[0] = "apple"
print(id(shopping), shopping)

1921962349576 ['apple', 'beer', 'chocolate', 'tomato', 'salad']

shopping.append("cucumber")
print(id(shopping), shopping)

1921962349576 ['apple', 'beer', 'chocolate', 'tomato', 'salad', 'cucumber', 'cucumber']

shopping.append("pasta")
print(id(shopping), shopping)

1921962349576 ['apple', 'beer', 'chocolate', 'tomato', 'salad', 'cucumber', 'cucumber', 'pasta']

del shopping[-1]
print(id(shopping), shopping)

1921962349576 ['apple', 'beer', 'chocolate', 'tomato', 'salad', 'cucumber', 'cucumber']

shopping.extend(["egg", "bread", "jam"])
print(id(shopping), shopping)

1921962349576 ['apple', 'beer', 'chocolate', 'tomato', 'salad', 'cucumber', 'cucumber', 'egg', 'bread', 'jam']

shopping.insert(0, "salt")
print(id(shopping), shopping)

1921962349576 ['salt', 'apple', 'beer', 'chocolate', 'tomato', 'salad', 'cucumber', 'cucumber', 'egg', 'bread', 'jam']

Les lists et les tuples supportent les opérateurs in, not in, ==, !=, + et *.

"egg" in shopping

True

"rice" not in shopping

True

shopping == ["egg", "chocolate"]

False

shopping != ["egg", "chocolate"]

True

["Bob"] + ["Bill"]

['Bob', 'Bill']

["Bob", "Bill"] * 3

['Bob', 'Bill', 'Bob', 'Bill', 'Bob', 'Bill']

On peut transformer les lists en tuples et vice versa avec les fonctions tuple et list.

l = ["Bob", "Bill"]
t = tuple(l)
print(type(t), t)

<class 'tuple'> ('Bob', 'Bill')

t = ["Bob", "Bill"]
l = list(t)
print(type(l), l)

<class 'list'> ['Bob', 'Bill']

Attention, lorsqu’on référence une list existante l1 avec un nouveam nom l2, les modifications de l2 modifient l1. Comme déjà évoqué, les noms en Python ne sont que des références à des objets. Dans le cas ci-dessous, la liste [1, 2, 3] est un objet unique auquel on peut accéder par les deux références/noms l1 et l2.

l1 = [1, 2, 3]
l2 = l1
l2[0] = 99
print(l1, l2)

[99, 2, 3] [99, 2, 3]

l1[1] = 999
print(l1, l2)

[99, 999, 3] [99, 999, 3]

l1 is l2

True

Copier une list est une action qu’on va vouloir faire de temps en temps. On utilise la fonction deepcopy du module copy.

import copy
l1 = [1, 2, 3]
l2 = copy.deepcopy(l1)
l2[0] = 999
print(l1, l2)

[1, 2, 3] [999, 2, 3]

l1 is l2

False

import copy
l1 = [[1], 2, 3]
l2 = copy.deepcopy(l1)
l2[0][0] = 999
print(l1, l2)

[[1], 2, 3] [[999], 2, 3]

l1[0] is l2[0]

False

Même si les objets de type list et tuple sont similaires, en général on ne les utilise pas de la même manière. Les lists vont plutôt contenir des objets du même type (exemple: liste de courses). Les tuples vont contenir une suite d’objets dont on est sûr à l’avance qu’elle n’aura pas besoin d’être modifiée (exemple: prénom et nom).

%reset -f

Dictionnaires

---

Ils font la paire

---

Les objets de type dict sont des containers et sont mutables. Ils sont constitués de paires key-value. Les keys doivent être des objets immutables, les values peuvent être n’importe quel type d’objet. Les dictionnaires sont très présents dans le langage Python.

phonebook = {
    "Bob": 383,
    "Bill": 509,
    "Donald": 102
}
phonebook

{'Bob': 383, 'Bill': 509, 'Donald': 102}

type(phonebook)

dict

On accède à une value que contient un dict par sa key.

phonebook["Bob"]

383

phonebook[383]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-973-9abd3fa563ad> in <module>
----> 1 phonebook[383]

KeyError: 383

phonebook["John"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-974-3f89bbc7ecee> in <module>
----> 1 phonebook["John"]

KeyError: 'John'

# Rajouter une key-value entrée
phonebook["John"] = 984
phonebook

{'Bob': 383, 'Bill': 509, 'Donald': 102, 'John': 984}

phonebook["John"]

984

# Vérifier si une key est dans le dict
"John" in phonebook

True

# Cela ne fonctionne que sur les keys, par sur les values
984 in phonebook

False

# Supprimer une paire key-value
del phonebook["John"]
phonebook["John"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-979-5eb835ec0b00> in <module>
      1 # Supprimer une paire key-value
      2 del phonebook["John"]
----> 3 phonebook["John"]

KeyError: 'John'

# Les dicts ne sont pas des séquences.
phonebook[0]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-980-6cd85588bf81> in <module>
      1 # Les dicts ne sont pas des séquences.
----> 2 phonebook[0]

KeyError: 0

# La longueur d'un dict est le nombre de paires key-value qu'il contient.
len(phonebook)

3

# Seuls des immutables peuvent être des keys
mess = {
    "str": "Les strings sont immutables",
    12: "Les ints sont immutables",
    3.53: "Les floats sont immutables",
    (12, 24): "Les tuples sont immutables"
}
mess

{'str': 'Les strings sont immutables',
 12: 'Les ints sont immutables',
 3.53: 'Les floats sont immutables',
 (12, 24): 'Les tuples sont immutables'}

# Les lists sont mutables, elles ne peuvent pas être des keys
mess[["list as a key"]] = 1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-983-1f3405e3d82b> in <module>
      1 # Les lists sont mutables, elles ne peuvent pas être des keys
----> 2 mess[["list as a key"]] = 1

TypeError: unhashable type: 'list'

# Les values d'un dict peuvent être de n'importe quel type.
import math
d = {
    3.13: math,
    "print": print,
    "l": [1, 2, 3],
    123: "123",
    "nested_dicts": {"another_one": {"and_a_last_one": "here I am!"}},
    "sets": {1, 3, 5},
    True: False
}
d

{3.13: <module 'math' (built-in)>,
 'print': <function print>,
 'l': [1, 2, 3],
 123: '123',
 'nested_dicts': {'another_one': {'and_a_last_one': 'here I am!'}},
 'sets': {1, 3, 5},
 True: False}

d["nested_dicts"]["another_one"]["and_a_last_one"]

'here I am!'

%reset -f

Fonctions

---

Don’t Repeat Yourself

---

On a déjà vu quelques unes des fonctions intégrées directement dans Python (built-in functions). On peut en fait créer nos propres fonctions. Cela est bien utile lorsqu’on souhaite réutiliser un bout de code, et/ou lorsqu’on souhaite faciliter la lecture/compréhension du code en le scindant en blocs logiques.

On crée un objet function avec le keyword ``def``. Une fonction retourne toujours un objet. On peut spécifier l’objet que doit retourner une fonction en le précédant du keyword ``return``. Si on ne spécifie rien, la fonction retourne None. L’exécution de la fonction se termine dès lors qu’elle retourne un objet.

def return_three():
    return 3

type(return_three)

function

Le code sous la définition de la fonction return_three est exécuté lorsqu’on appelle la fonction avec les symboles ().

return_three()

3

Une fonction peut avoir des paramètres. On les précise sur la ligne de définition de la fonction. Ils peuvent ensuite être utilisés dans la fonction. La fonction add a deux paramètres x et y.

def add(x, y):
    return x + y

La fonction add est appelée avec les arguments 3 et 4.

add(3, 4)

7

result = add(3, 4)

result

7

On a des fois pas besoin qu’une fonction retourne un objet spécifique. Elle retourne alors None.

def say_hi_many_times(nb_of_times):
    print("Hi " * nb_of_times)

say_hi_many_times(10)

Hi Hi Hi Hi Hi Hi Hi Hi Hi Hi

output = say_hi_many_times(10)

Hi Hi Hi Hi Hi Hi Hi Hi Hi Hi

output is None

True

L’objet string entouré de """ et positionné au début du bloc de la fonction est la docstring de la fonction.

def add(x, y):
    """Additioner deux objets."""
    return x + y

help(add)

Help on function add in module __main__:

add(x, y)
    Additioner deux objets.

Certains paramètres peuvent avoir des valeurs par défaut. Lorsqu’on appelle la fonction, on n’est donc pas obligé de préciser la valeur de ce paramètre (ce qui équivaut à dire qu’on n’est pas obligé de fournir un argument pour ce paramètre). Dans ce cas-là, la valeur par défaut est utilisée lors de l’exécution du code. Lorsqu’on souhaite utiliser une autre valeur que la valeur par défaut, on peut soit fournir l’argument si on respecte l’ordre des paramètres, on peut aussi fournir l’argument en nommant le paramètre (``param=arg``).

print?

def function_with_defaults(a, b, c=0):
    return a + b + c
function_with_defaults(1, 4)

5

function_with_defaults(1, 4, c=50)

55

function_with_defaults(1, 4, 5)

10

function_with_defaults(c=50, 1, 4)

  File "<ipython-input-1004-e132c12cc603>", line 1
    function_with_defaults(c=50, 1, 4)
                                ^
SyntaxError: positional argument follows keyword argument

function_with_defaults(c=50, b=4, a=1)

55

Une fonction peut appeler une autre fonction.

def first():
    print("first function called")
    second()

def second():
    print("second function called")

first()

first function called
second function called

Lorsqu’on exécute le bloc de définition d’une fonction (la ligne def et le bloc indenté qui suit), Python se prépare à exécuter la fonction mais ne l’exécute pas encore, elle ne le sera que lorsqu’elle sera appelée. A part les erreurs de syntaxe et d’indentation que Python détecte lors de cette étape de préparation, toutes les autres erreurs sont détectées seulement lorsque la fonction est appelée.

# unknown n'est pas une variable définie, malgré ça, on peut exécuter ce code
def dont_even_dare():
    return unknown

# On obtient une erreur lorsqu'on appelle la fonction dont_even_dare
dont_even_dare()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1009-a64b5e067227> in <module>
      1 # On obtient une erreur lorsqu'on appelle la fonction dont_even_dare
----> 2 dont_even_dare()

<ipython-input-1008-c0383c067b3c> in dont_even_dare()
      1 # unknown n'est pas une variable définie, malgré ça, on peut exécuter ce code
      2 def dont_even_dare():
----> 3     return unknown

NameError: name 'unknown' is not defined

L’exécution d’une fonction se passe dans son scope local. Les objets référencés par la fonction (firstname = "Bob") sont déférencés lorsque l’exécution prend fin. On ne peut plus y avoir accès après ça.

def function_scope():
    firstname = "Bob"
function_scope()
firstname

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1010-88897d2c37bf> in <module>
      2     firstname = "Bob"
      3 function_scope()
----> 4 firstname

NameError: name 'firstname' is not defined

Même la référence de l’objet retourné par la fonction est supprimée à la fin de l’exécution.

def function_scope():
    firstname = "Bob"
    return firstname
function_scope()
firstname

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-603-adec7aecec8c> in <module>
      3     return firstname
      4 function_scope()
----> 5 firstname

NameError: name 'firstname' is not defined

Pour préserver l’objet retourné on lui associe un nom.

firstname = function_scope()
firstname

'Bob'

x ci-dessous n’est ni un paramètre de la fonction look_outside ni un objet créé dans la fonction. Lorsqu’on exécute look_outside, Python regarde d’aborde dans le scope local de la fonction s’il existe une référence x. Comme il ne la trouve pas, Il cherche alors dans le scope global de la fonction.

Dans le premier cas ci-dessous, aucune référence x n’est créée en dehors du scope de la fonction. Une erreur est donc déclenchée.

def look_outside(b):
    return x + b

look_outside(20)

23.4

Ici, comme la référence x est créée (ajoutée au namespace) avant l’exécution de look_outside, celle-ci peut la trouver et s’exécute donc jusqu’à son terme.

def look_outside(b):
    return x + b

x = 10
look_outside(20)

30

def look_inside_first(b):
    x = 0
    return x + b

x = 10
look_inside_first(20)

20

Attention aux objets mutables passés comme argument à une fonction. Lorsqu’on passe un argument à une fonction, celle-ci utilise directement l’objet référencé.

def is_same_objet(n):
    print(n is name)

name = "Bob"
is_same_objet(name)

True

Si on passe un objet mutable comme argument d’une fonction, cette fonction va utiliser directement cet objet. S’il est modifié au cours de l’exécution de la fonction, c’est le bien mutable source qui est modifié, même s’il n’a pas la même référence dans la fonction.

def change_mutable(mutable):
    mutable[0] = "John"
    return mutable

names = ["Bill", "Rachel", "Bob"]
new_names = change_mutable(names)
print("new_names:", new_names, "\nnames:", names)

new_names: ['John', 'Rachel', 'Bob']
names: ['John', 'Rachel', 'Bob']

Si ce comportement n’est pas souhaité, on peut soit appeler la fonction avec une copie du mutable, soit créer une copie directement dans le bloc de la fonction.

names = ["Bill", "Rachel", "Bob"]
new_names = change_mutable(names[:])
print("new_names:", new_names, "\nnames:", names)

new_names: ['John', 'Rachel', 'Bob']
names: ['Bill', 'Rachel', 'Bob']

%reset -f

Unpacking, Packing

---

Déballer son sac

---

On peut facilement extraire un à un les éléments d’un objet iterable (séquences et containers) pour assigner de nouvelles variables avec la méthode dite de l”unpacking. Cela se fait le plus souvent à partir d’un tuple.

t = ("Bob", 27, ["Sarah", "Jim"])

t comprend trois éléments, ces trois éléments sont assignés dans l’ordre aux variables name, age et siblings.

name, age, siblings = t
print(name, age, siblings)

Bob 27 ['Sarah', 'Jim']

Mais on peut aussi le faire avec d’autres types d’objet.

l = ["Bob", 27, ["Sarah", "Jim"]]
name, age, siblings = l
print(name, age, siblings)

Bob 27 ['Sarah', 'Jim']

s = "abc"
a, b, c = s
print(a, b, c)

a b c

x = 3.4
pint, pdec = 3.4

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-617-5c0c97d6e39b> in <module>
      1 x = 3.4
----> 2 pint, pdec = 3.4

TypeError: cannot unpack non-iterable float object

Packing est l’action par laquelle plusieurs objets sont rassemblés dans un tuple.

"Bob", 27, ["Sarah", "Jim"]

('Bob', 27, ['Sarah', 'Jim'])

packed = "Bob", 27, ["Sarah", "Jim"]
packed

('Bob', 27, ['Sarah', 'Jim'])

type(packed)

tuple

Lorsqu’on essaie de retourner plusieurs objets dans une fonction, ceux-ci sont en fait toujours rassemblés dans un ``tuple``. Packing est à l’oeuvre.

def person_info():
    return "Anna", 26  # équivalent à return ("Anna", 26)

output = person_info()
type(output)

tuple

On peut utiliser l”unpacking pour assigner à des variables les objets retournés par la fonction person_info.

name, age = person_info()
print(name, age)

Anna 26

%reset -f

Boucle for et fonctions associées

---

May the for be with you

---

Les boucles ``for`` sont très simples et utiles en Python. Elles permettent de répéter un bloc d’instructions un certain nombre de fois. L’objet qui suit le keyword in doit être un iterable.

for i in range(3):
    print(i)

0
1
2

range?

range est une fonction qui accepte 3 arguments start, stop et step. Par défaut start est égal à 0 et step à 1. Cette fonction ne retourne pas une liste mais un obtjet de type range. Il s’agit d’un objet un peu spécial. Lorsqu’on exécute range(1_000_001), considérant le code de la cellule précédente, on pourrait penser que cette instruction génère des nombres de 0 à 1000000, mais non. Cet objet est une sorte de distributeur, il ne fait rien tant qu’on ne lui demande rien. Lorsqu’on lui demande quelque chose, comme dans une boucle for, il s’active et commence à distribuer. Dans le cas de range(1_000_001), l’objet distribue des ints en commençant à 0, un par un, jusqu’à 1000000.

for i in range(3):
    print(id(i))

140734432776992
140734432777024
140734432777056

type(range(3))

range

Pour créer une liste croissante d’entiers, on peut convertir un objet range en liste avec la fonction list.

list(range(3))

[0, 1, 2]

La boucle for de Python est en fait similaire à une boucle for each, elle extrait chaque élément de l”iterable sur laquelle elle agit.

names = ["Bob", "Bill", "Sarah", "Anna"]
for name in names:
    print(name)

Bob
Bill
Sarah
Anna

On peut pratiquer l”unpacking dans la ligne de la boucle for.

fullnames = [("Rachel", "Miller"), ("Bob", "Smith"), ("Anna", "Johnson"), ("Bill", "Davis")]
for first_name, last_name in fullnames:
    print(first_name, last_name)

Rachel Miller
Bob Smith
Anna Johnson
Bill Davis

On peut utiliser la boucle for pour itérer au travers des objets de type string, list, tuple, dict, set (et plus encore).

txt = "abcdefghi"
for letter in txt:
    print(letter)

a
b
c
d
e
f
g
h
i

names = ("Bob", "Bill", "Sarah", "Anna")
for name in names:
    print(name)

Bob
Bill
Sarah
Anna

phonebook = {
    "Bob": 383,
    "Bill": 509,
    "Donald": 102
}
for k in phonebook:
    print(k)

Bob
Bill
Donald

for k, v in phonebook.items():
    print(k, v)

Bob 383
Bill 509
Donald 102

for v in phonebook.values():
    print(v)

383
509
102

On peut inverser l’ordre des itérations en appelant la fonction reversed sur l”iterable.

for name in reversed(names):
    print(name)

Anna
Sarah
Bill
Bob

Un peu comme la fonction range, la fonction reversed ne retourne pas une list mais un objet qualifié d”iterator. Il s’agit aussi d’un distributeur, il distribue dans ce cas-là les éléments de l”iterable en commençant par le dernier. Comme on peut itérer sur un iterator, ce type d’objet est aussi un iterable.

reversed(names)

<reversed at 0x1bf7f0fbfd0>

reversed(names)[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-640-0f87fe6cd96c> in <module>
----> 1 reversed(names)[0]

TypeError: 'reversed' object is not subscriptable

Les iterators sont des objets qui se tarissent. Après leur avoir demandé de distribuer leur « contenu » une fois, ils ne peuvent plus le redistribuer.

reversed_names = reversed(names)
list(reversed_names)

['Anna', 'Sarah', 'Bill', 'Bob']

list(reversed_names)

[]

reserved_names est maintenant un iterator vide, on ne peut plus le réutiliser. (A noter que l’objet retourné par range ressemble à un iterator mais n’en est en fait pas un, on peut donc le réutiliser).

for name in sorted(names):
    print(name)

Anna
Bill
Bob
Sarah

for name in sorted(names, key=len):
    print(name)

Bob
Bill
Anna
Sarah

sorted ne retourne pas un iterator mais directement une list.

sorted(names)

['Anna', 'Bill', 'Bob', 'Sarah']

type(sorted(names))

list

La fonction ``enumerate`` fournit sous la forme d’un ``tuple`` un compteur et les les éléments de l’iterable avec laquelle elle est appelée.

for i, name in enumerate(names):
    print(f"Iteration {i}: {name}")

Iteration 0: Bob
Iteration 1: Bill
Iteration 2: Sarah
Iteration 3: Anna

for i, name in enumerate(reversed(names)):
    print(f"Iteration {i}: {name}")

Iteration 0: Anna
Iteration 1: Sarah
Iteration 2: Bill
Iteration 3: Bob

L’objet que la fonction enumerate retourne est un iterator.

enumerated_names = enumerate(names)

list(enumerated_names)

[(0, 'Bob'), (1, 'Bill'), (2, 'Sarah'), (3, 'Anna')]

list(enumerated_names)

[]

La function zip permet d’itérer sur plusieurs iterables en extrayant leur élément en même temps. L’objet qu’elle retourne est un iterator.

ages = [25, 28, 23, 21]
first_letters = ["B", "R", "B", "A"]

for name, first_letter, age in zip(names, first_letters, ages):
    print(name, first_letter, age)

Bob B 25
Bill R 28
Sarah B 23
Anna A 21

for i, (name, first_letter, age) in enumerate(zip(names, first_letters, ages)):
    print(i, name, first_letter, age)

0 Bob B 25
1 Bill R 28
2 Sarah B 23
3 Anna A 21

Mais que se passe-t-il exactement lorsqu’on exécute une boucle for? A chaque itération, un élément de l”iterable est référencé par le nom défini juste après le keyword for. On peut voir que les objets extraits d’une list sont exactement les objets auxquels elle fait référence.

On a souvent besoin de modifier un à un les éléments d’une ``list`` (exemple: mettre des noms en capitales). la méthode recommandée est la suivante: * On crée une list vide avec l = [] * A chaque itération on vient rajouter un élément à cette list vide avec la méthode append (l.append(new_item))

names = ["Bob", "Bill", "Sarah", "Rachel"]
upper_names = []
for name in names:
    upper_names.append(name.upper())
upper_names

['BOB', 'BILL', 'SARAH', 'RACHEL']

On peut inclure des conditions if dans le bloc d’une boucle for pour préciser les actions à effectuer.

for name in names:
    if "S" in name:
        if "a" in name:
            if "r" in name:
                print(f"I think you're Sarah, correct? \nYes I'm {name}!")

I think you're Sarah, correct?
Yes I'm Sarah!

Cela génère des fois du code qui est très indenté et pas facile à lire, on peut utiliser les *keywords* ``continue`` et ``break`` pour contrôler l’exécution de la boucle. continue entraîne le démarrage direct de la prochaine itération, ainsi, tout le code qui est situé sous continue est passé si continue est exécuté. break arrête totalement l’exécution de la boucle.

for name in names:
    if "S" not in name:
        continue
    if "a" not in name:
        continue
    if "r" not in name:
        continue
    # Exécuté si les trois conditions ci-dessus sont fausses
    print(f"I think you're Sarah, correct? \nYes I'm {name}!")
    break

I think you're Sarah, correct?
Yes I'm Sarah!

for name in names:
    if name == "Sarah":
        continue
    print(name)  # Exécuté si name != "Sarah"

Bob
Bill
Rachel

for name in names:
    if name == "Sarah":
        break  # Stoppe la boucle lorsque name == "Sarah"
    print(name)

Bob
Bill

Contrairement aux références créés dans le scope d’une fonction, les références créés dans un bloc for ne sont pas supprimées à la fin de l’exécution du bloc. La référence name est donc toujours accessible et sa valeur est celle de la dernière itération. Ici on voit que sa valeur est 'Sarah', ce qui a effectivement stoppé l’exécution de la boucle.

name

'Sarah'

Lire et écrire dans un fichier

---

Cours Primaire

---

On peut facilement lire le contenu d’un fichier texte et écrire du texte dans un fichier. Pour cela, on utilise: * la fonction open qui permet d’ouvrir un fichier et de le lire ou d’y écrire quelque chose * le keyword with qui signale l’utilisation d’un objet qualifié de context manager (ici, la fonction open). L’emploi de ce genre d’objet avec un bloc ``with`` permet de s’assurer de la fermeture de la ressource ouverte (ici, un fichier), même si une erreur se produit dans l’exécution du bloc de code

%%writefile data.txt
name,age,gender
Sarah,27,F
Bob,28,M
Rachel,24,F
Bill,22,M

Writing data.txt

La fonction open ouvre le fichier en mode lecture ("r" pour read) et retourne un objet référencé par f (on peut choisir n’importe quel nom) et lié au fichier en cours de lecture.

with open("data.txt", "r") as f:
    print(type(f))
    print(dir(f))

<class '_io.TextIOWrapper'>
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']

On peut lire le contenu d’un fichier ligne par ligne en itérant sur l’objet retourné par la fonction open. Cet objet est en fait un iterator. Chaque ligne du fichier se termine par un caractère retour à la ligne. On peut donner l’argument end="" à la fonction print pour qu’elle ne saute pas trop de lignes.

with open("data.txt", "r") as f:
    for line in f:
        print(line)

name,age,gender

Sarah,27,F

Bob,28,M

Rachel,24,F

Bill,22,M

with open("data.txt", "r") as f:
    for line in f:
        print(line, end="")

name,age,gender
Sarah,27,F
Bob,28,M
Rachel,24,F
Bill,22,M

Comme f est un iterator, on ne peut itérer dessus qu’un seule fois.

with open("data.txt", "r") as f:
    for line in f:
        print(line, end="")
    for line in f:
        print(line, end="")

name,age,gender
Sarah,27,F
Bob,28,M
Rachel,24,F
Bill,22,M

L’avantage de lire un fichier ligne par ligne est double: * On ne charge pas l’ensemble des données du fichier dans la mémoire * On peut arrêter sa lecture avant la fin si on cherche quelque chose de précis

with open("data.txt", "r") as f:
    for i, line in enumerate(f):
        if "Bob" in line:
            print(f"I've found Bob @line {i + 1} !!!")
            break  # Stoppe la lecture du fichier

I've found Bob @line 3 !!!

with open("data.txt", "r") as f:
    for i, line in enumerate(f):
        line = line.strip()
        if line.startswith("Bob"):
            age = line.split(",")[1]
            break
print(f"Bob is {age} yo.")

Bob is 28 yo.

Pour écrire dans un nouveau fichier, la démarche est tout à fait similare. Au lieu de passer l’argument r à la fonction open, on lui passe l’argument w (pour write). La méthode write n’accepte comme argument que des objets de type string. Au besoin, on convertit les objets (float) par exemple en string en les passant comme argument à la fonction str. Il faut faire attention à inclure le caractère spécial "\n" pour marquer les sauts de ligne.

names = ["Sarah", "Rachel", "Bob", "Bill"]
with open("new_data.txt", "w") as f:
    for name in names:
        f.write(name + "\n")

!type new_data.txt

Sarah
Rachel
Bob
Bill

!del /f new_data.txt data.txt
%reset -f

Traceback

---

Suivie à la trace

---

Le traceback est le long message que Python affiche lorsqu’une erreur survient pendant l’exécution du code. Le traceback se lit de bas en haut. Il est très utile pour débugger un script.

def first_level(a, b):
    return second_level(a, b)


def second_level(a, b):
    return third_level(a, b)


def third_level(a, b):
    return a + b

first_level(1, 2)

3

L’addition des paramètres a et b est réalisée par la fonction third_level. On va déclencher une TypeError en tentant d’additioner une string avec un int, ce qui est impossible.

"Bob" + 1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-676-1e6b406786db> in <module>
----> 1 "Bob" + 1

TypeError: can only concatenate str (not "int") to str

first_level("Bob", 1)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-677-26206af4b823> in <module>
----> 1 first_level("Bob", 1)

<ipython-input-674-0c177701bd8c> in first_level(a, b)
      1 def first_level(a, b):
----> 2     return second_level(a, b)
      3
      4
      5 def second_level(a, b):

<ipython-input-674-0c177701bd8c> in second_level(a, b)
      4
      5 def second_level(a, b):
----> 6     return third_level(a, b)
      7
      8

<ipython-input-674-0c177701bd8c> in third_level(a, b)
      8
      9 def third_level(a, b):
---> 10     return a + b

TypeError: can only concatenate str (not "int") to str

Le traceback nous indique que l’erreur s’est produite à la ligne return a + b du code dans la fonction third_level. Il afficher ensuite (de bas en haut) les appels successifs aux trois fonctions imbriquées.

%reset -f