2ZZ1303 Syl1 1

INSTITUT SUPERIEUR INDUSTRIEL DE BRUXELLES
Nom : Mattens Jean-Michel
Titre du syllabus : Introduction à la programmation Python 3
Acronyme de l’activité d’apprentissage : 2ZZ1303
Informations complémentaires :
Mattens Jean-Michel Edition 2022/2023

HE2B - ISIB 2022/2023 ÉLECTRONIQUE & INFORMATIQUE II - Laboratoire de techniques informatiques 1 - J.M. Mattens 2
1 RESSOURCES ET RÉFÉRENCES
 Syllabus INFO-H-100 Informatique, Thierry Massart, ULB
 Apprendre à programmer avec Python", Gérard Swinnen, en téléchargement libre à partir du site
http://inforef.be/swi/python.htm
 Think Python, Allen Downey, en téléchargement libre à partir du site

http://www.greenteapress.com/thinkpython/
 https://www.python.org/

 https://docs.python.org/3/tutorial/
Introduction à la programmation Python

2 PRÉSENTATION
2.1 Qu’est Python ?
 Un langage de haut niveau et multi-paradigmes (programmation impérative, orientée objet,
fonctionnelle)
 Portable
 Interprété
 Doté d’un typage fort , dynamique  et implicite 
 Relativement orthogonal (utilise un petit nombre de concepts de base)
 Utilisant des références (pas de pointeurs de bas niveau) et disposant d’un « garbage collector »
 Proposant des types de données évolués (tuples, listes, dictionnaires, ensembles, …)
 Doté d’un mécanisme de gestion des exceptions
 Gratuit

3 PRÉLIMINAIRES
 Les (fins de) lignes de commentaire commencent par : #
 La première ligne devrait ressembler à : #!/usr/bin/env python3
 Il est conseillé d’utiliser l’extension py pour les scripts Python.
 Les fichiers sources doivent être encodés en UTF-8
 On peut obtenir de l’aide avec :
o help() dans le shell interactif de python
o Un client http ( « browser ») et aller sur le site https://www.python.org/
o Les fichiers d’aide locaux (par exemple activepython34.chm)

4 UNE PREMIÈRE PRISE EN MAIN AVEC LE SHELL

INTERACTIF DE PYTHON
ActivePython 3.4.1.0 (ActiveState Software

Inc.) based on
Python 3.4.1 (default, Aug 7 2014,
13:09:27) [MSC v.1600 64 bit (AMD64)] on
win32
Type "help", "copyright", "credits" or
"license" for more information.
>>> 5*(3+4)**2 ** est l’élévation à la puissance
245 ** est de priorité plus élevée que *, /, //
>>> 8/3 Python 2 -> 2
2.6666666666666665
>>> 8//3 Spécifique python 3
2
>>> 8%3
2
>>> 2**2**3 ** est associatif par la droite
256
>>> 2**128 Les entiers sont codés sur 32 ou 64 bits
340282366920938463463374607431768211456 tant qu’ils ne sont pas trop grands
mais il y a extension automatique !
>>> 4/3*3.1416*1.5**3
14.137199999999998
>>> 'gains'+'bar' Les litéraux de chaînes de caractères

'gainsbar' peuvent être délimités par ' ou ".
>>> "gains"+"bar"
'gainsbar'
>>> "bla"*3
'blablabla'
>>> x=1 La variable x ne doit pas être déclarée.

>>> x Le typage est dynamique et implicite.
1
>>> type(x) x est en fait une référence à l’objet « 1 »
<class 'int'> de type <class 'int'>
>>> y=2
>>> y is x y et x font-ils référence à un même objet ?
False
>>> z=x
>>> z is x z et x sont deux références vers un
True même objet !
>>> x=x+1 Il y a créaction d’un nouvel objet « 2 »
>>> z is x z fait toujours référence à l’objet « 1 »
False
>>> x=3
>>> y=3
>>> x is y Les objets de type <class ‘int’> sont
True immuables, donc il est possible de les
recycler ! Cf. les strings en Java.
>>> x=1.2 x fait référence à un nouvel objet.

L’objet « 3 » n’est pas perdu car y lui
fait toujours référence.
Cf. garbage collector.
>>> x
1.2
>>> type(x) Généralement le type float utilise
<class 'float'> la norme IEEE-758 « double precision »
>>> y=2.2
>>> y is x
False
>>> z=x
>>> z is x
True
>>> x=x+1
>>> x
2.2
>>> z
1.2
>>> x="hello" Les chaînes sont des séquences immuables

>>> x de caractères.
'hello'
>>> type(x)
<class 'str'>
>>> len(x)
5
>>> y='you' " ou ' peuvent être utilisés pour
écrire les litéraux de string.
>>> y is x
False
>>> z=x
>>> z is x
True
>>> x=x*3
>>> z is x
False
>>> x='this one'
>>> y="this one"
>>> x is y Ce shell n’a pas recyclé 'this one'.
False Il aurait pu !
Faites le test dans un script
Vous aurez peut-être True !
>>> x=(1,2,'trois') Les tuples sont des séquences immuables

>>> x d’éléments pouvant être de types
(1, 2, 'trois') différents.
>>> type(x) Ils sont des types de données non simples :
<class 'tuple'> ils sont constitués de parties (comme
les strings par exemple).
Les litéraux de tuples sont délimités
par ().
>>> len(x)
3
>>> y=1,2,'trois' Les () peuvent être omises.
>>> x[1] Le premier indice est 0.
2
>>> y[2]=3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support
item assignment
>>> z=((1,2,3),(4,5,6)) z fait référence à un tuple de deux
>>> z références à des tuples...
((1, 2, 3), (4, 5, 6))
>>> z=3
>>> z
3
>>> z=(3,) La , est nécessaire pour avoir un tuple.
>>> z
(3,)
>>> x=[1,2,'trois'] Les listes sont des séquences muables

>>> x d’éléments pouvant être de types
[1, 2, 'trois'] différents.
>>> type(x) Ce sont des types de données non simples.
<class 'list'> Les litéraux de listes sont délimités
par [].
>>> len(x)
3

>>> x[1] Le premier indice est 0.

2
>>> x[2]=3
>>> x.append('quatre')
>>> x.extend([5,6])
>>> x.insert(0,'zero')
>>> x
['zero', 1, 2, 3, 'quatre', 5, 6]
>>> x.pop() Retire et renvoie le dernier élément.
6
>>> x
['zero', 1, 2, 3, 'quatre', 5]
>>> del(x[1])
>>> x
['zero', 2, 3, 'quatre', 5]
>>> z=[[1,"deux"],(3,4),'cinq'] Les listes n’ont qu’un indice mais elles
>>> z peuvent contenir des listes, des tuples,
[[1, 'deux'], (3, 4), 'cinq'] ...
>>> x={0,'un',2,"trois"} Les ensembles sont des types de données

>>> x non simples muables.
{'trois', 0, 2, 'un'} Ce ne sont pas des séquences (pas de
>>> type(x) notion d’indice)
<class 'set'> Les litéraux sont délimités par {}.
>>> len(x)
4
>>> 0 in x
True
>>> 'zero' in x
False
>>> x.add(5)
>>> x
{'trois', 0, 2, 5, 'un'}
>>> x.remove(2) L’élément 2 !
>>> x
{'trois', 0, 5, 'un'}
>>> x.pop() Retire et renvoie un élément « au hasard ».
'trois'
>>> x
{0, 5, 'un'}
>>> x.clear()
>>> x
set()
>>> x={'one': 'un', 2 : 'deux', 'three' : Les dictionnaires sont des séquences
3} modifiables où les « indices » (les clés)
>>> x ne sont pas forcément des entiers.
{'three': 3, 'one': 'un', 2: 'deux'} A chaque clé correspond une valeur.
>>> type(x) Les clés doivent être de type non
<class 'dict'> modifiable.
>>> len(x)
3
>>> 2 in x
True
>>> 'deux' in x C’est la clé qui est testée !
False
>>> x['one']
'un'
>>> x['one']='uno' Modification de la valeur associée
>>> x à la clé.
{'three': 3, 'one': 'uno', 2: 'deux'}
>>> x[4]='uno' Ajoute la paire clé-valeur si la clé
>>> x n’est pas présente.
{'three': 3, 'one': 'uno', 2: 'deux', 4:
'uno'}
>>> x[5] Cette clé ,est pas présente dans le dico !

KeyError: 5
>>> x[6]=[1,2,3]
>>> x
{'three': 3, 'one': 'uno', 2: 'deux', 4:
'uno', 6: [1, 2, 3]}
>>> x.keys() Renvoie la liste des clés.
dict_keys(['three', 'one', 2, 4, 6])
>>> x.values() Renvoie la liste des valeurs.
dict_values([3, 'uno', 'deux', 'uno', [1,
2, 3]])
>>> x.items() Renvoie la liste des tuples clé-valeur.
dict_items([('three', 3), ('one', 'uno'),
(2, 'deux'), (4, 'uno'), (6, [1, 2, 3])])
>>> x.pop(2) Renvoie la valeur associée à la clé et
'deux' retire la paire clé-valeur.
>>> x
{'three': 3, 'one': 'uno', 4: 'uno', 6: [1,
2, 3]}
>>> x.pop(2) La clé n’est pas présente -> exception.
KeyError: 2
>>> x.pop(2,'aie') Si la clé n’est pas présente, renvoie
'aie' 'aie', sinon renvoie la valeur associé.
>>> x
{'three': 3, 'one': 'uno', 4: 'uno', 6: [1,
2, 3]}
>>> x.setdefault('one','un') setdefault() prend une clé et une valeur
'uno' en paramètre. Si la clé existe elle
>>> x.setdefault('seven',7) retourne la valeur, si la clé n’existe pas
7 elle ajoute la paire clé-valeur et
>>> x retourne la valeur par défaut.
{'one': 'uno', 4: 'uno', 6: [1, 2, 3],
'three': 3, 'seven': 7}
>>> (x,y,z)=(1,2,3) Unpacking !

>>> (x,y,z)
(1, 2, 3)
>>> x,y,z=1,2,3
>>> x,y,z
(1, 2, 3)
>>> x,y=y,x Ceci est une vraie permutation !

>>> x,y
(2, 1)
>>> t=1,2,3 Packing !

>>> t
(1, 2, 3)
>>> a,b,c=t Unpacking.

>>> a
1
>>> b
2
>>> c
3
>>> a=int(3.99) Convertion de float en int.

>>> a Arrondi vers 0.
3
>>> b=int(-3.99)
>>> b
-3
>>> s='123' Conversion de string en int.
>>> c=int(s)
>>> c
123
>>> abs(-1.2)
1.2
>>> dir('abc') Renvoie des « noms » associés à l’objets.
['__add__', '__class__', '__contains__',
'__delattr__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__',
'__getnewargs__', '__gt__', '__hash__',
'__init__', '__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', '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']
>>> dir(str)
['__add__', '__class__', '__contains__',
'__delattr__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__',
'__getnewargs__', '__gt__', '__hash__',
'__init__', '__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', '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']
>>> divmod(27,5)
(5, 2)
>>> help(divmod) Aide dans le shell.
Help on built-in function divmod in module
builtins:
divmod(...)
divmod(x, y) -> (div, mod)
Return the tuple ((x-x%y)/y, x%y).

Invariant: div*y + mod == x.

>>> eval('2*abs(-5)**2') Traite la chaîne somme une expression et

50 l’évalue.
>>> float('3.1416') Conversion de string en float.

3.1416
>>> x=input('x? ') Affiche l’invite et lit un string.

x? 1.1 x fait référence à '1.1'
>>> max(1,2,3,2,1)
3
>>> min(4,3,2,1)
1
>>> round(3.567)
4
>>> round(3.567,2)
3.57
>>>
>>> import math Pour employer un module, il faut
l’importer.
>>> math.sin(math.pi/6.0)
0.49999999999999994
>>> import math as m
>>> m.sin(m.pi/6.0)
0.49999999999999994
>>> from math import pi,sin
>>> sin(pi/6.0)
0.49999999999999994
>>> from math import * NE PAS FAIRE CELA CAR :
- ne permet pas de savoir la provenance
des éléments utilisés,
- peut cacher des éléments existants qui
ont le même nom
- peut provoquer des collisions de noms
- rend le code difficile à debugger quand
un symbole est indéfini
>>> 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', 'hypot',
'isfinite', 'isinf', 'isnan', 'ldexp',
'lgamma', 'log', 'log10', 'log1p', 'log2',
'modf', 'pi', 'pow', 'radians', 'sin',
'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>>
>>>exit() Fin du shell python

5 PREMIERS SCRIPTS
5.1 prog1.py
Le script :
#!/usr/bin/env python3
"""
Calcule la somme des deux nombres flottants transmis dans la ligne de commandes.
Hypothèses : les flottants transmis sont des litéraux de float valides.
"""
__author__ = "JM Mattens"

__date__ = "21 juillet 2015"
import sys
if len(sys.argv) != 3: # sys.argv is a list

print("Il faut deux arguments!", file=sys.stderr)
exit(1)
a = float(sys.argv[1])
b = float(sys.argv[2])
print(a, '+', b, ' = ', a + b)
L’affichage produit lorsqu’on transmet les arguments 1.1 et 2.2 au script :
1.1+ 2.2 = 3.3000000000000003
Remarques :
 """ permet d’introduire des commentaires multi lignes.

 Les commentaires multi lignes permettent de documenter les fonctions utilisateur.
 __author__ et __ date__ sont des variables conventionnellement utilisées pour identifier l’auteur
et la date d’écriture du script.
 Il faut importer le module sys pour avoir accès aux arguments du script.
 argv est une liste de chaînes de caractères correspondant aux arguments passés au script, argv[0] est
le nom du script.
 Les blocs de code sont définis grâce à l’indentation en Python (pas les {} comme en java et c).
 La fonction print() permet d’écrire dans la console. Elle accepte un nombre variable d’arguments
séparés par des virgules. Ces arguments sont convertis en strings (cf. str()).
 Les fonctions peuvent définir des valeurs par défaut pour certains paramètres (ils doivent suivre ceux
qui n’ont pas de valeur par défaut dans la déclaration). Voir le paramètre file de print().
 Python permet de spécifier les arguments ayant une valeur par défaut par leurs noms, ce qui permet
d’utiliser un autre ordre lors de l’appel que celui utilisé dans la déclaration des paramètres.

5.2 prog2.py
Le script :
"""
Calcule la somme des deux nombres flottants saisis au clavier.
Hypothèses : les flottants saisis sont des litéraux de float valides.
"""

__date__ = "21 juillet 2015"
print("Addition de deux nombres flottants a et b")

a = float(input('a ? '))
b = float(input('b ? '))
print(a, '+', b, ' = ', a + b)
# print("%10.2f + %-10.2f = %-10.2f" % (a,b,a+b)) # old printf way
# print("{0:>10.2f} + {1:<10.2f} = {2:<10.2f}".format(a,b,a+b)) # pythonic way
Un affichage possible :
Addition de deux nombres flottants a et b

a ? 1.1
b ? 2.2
1.1 + 2.2 = 3.3000000000000003
Remarque :
 input() renvoie un string, il faut donc convertir en float.

6 STRUCTURE CONDITIONELLE
6.1 Structure conditionnelle if …
Syntaxe :
"if" expression ":" suite

("elif" expression ":" suite )*
["else" ":" suite]
où
 expression est une expression booléenne

 suite un bloc d’instructions (indentées)
 ( ... )\* est une méta-notation signifiant que la ligne peut apparaître 0 ou plus fois
 [ ... ] est une méta-notation signifiant que la ligne est optionnelle (0 ou 1 fois).
6.2 Script ifDemo.py

Le script :
"""
Résout une équation du premier degré a X + b = 0 dont les
coefficients a et b sont deux nombres flottants saisis au clavier.
Hypothèses : les flottants saisis sont des litéraux de float valides.
"""

__date__ = "21 juillet 2015"
print("Résolution d'une équation du premier degré a X + b = 0")

a = float(input("a ? "))
b = float(input("b ? "))
if a != 0.0:
print("La solution du système est unique")
print("x = ", -b / a)
elif b != 0.0:
print("Equation impossible")
else:
print("Equation indéterminée")

Quelques affichages possibles :
Résolution d'une équation du premier degré a X + b = 0

a ? 0.5
b ? 1.5
La solution du système est unique
x = -3.0

a ? 0
b ? 1.5
Equation impossible

a ? 0
b ? 0
Equation indéterminée
Remarques :
 Python pratique le « court-circuitage » d’expressions logiques (« lazy evaluation »).

 Il n’y a pas d’instruction switch en Python.

7 STRUCTURES RÉPÉTITIVES
7.1 Structure répétitive while …
Syntaxe :
"while" expression ":" suite

["else" ":" suite]
où
 expression est une expression booléenne

 suite un bloc d’instructions (indentées)
 [ ... ] est une méta-notation signifiant que la ligne est optionnelle (0 ou 1 fois).
Si la clause else est présente, elle sera exécutée une seule fois lorsque expression s’évalue à False.
7.1.1 Script whileDemo1.py

Le script :
"""
Jeu de la devinette du nombre.
Il faut trouver un nombre généré aléatoirement. Chaque fois que le joueur
propose un nombre, le programme indique s'il est trop petit, trop grand ou
exact.
"""

__date__ = "21 juillet 2015"
import random
MAX = 1000
print("Vous devez deviner un nombre compris entre 0 et ", MAX, sep="")

random.seed()
number = random.randint(0, 1000)
guess = int(input("Votre nombre ? "))
nbr_trials = 1
while guess != number:
if guess < number:
print(guess, 'est trop petit')
else:
print(guess, 'est trop grand')
guess = int(input("Votre nombre ? "))
# ++nbr_trials bad!
nbr_trials += 1
print("\nVous avez trouvé en", nbr_trials, "essais.")

Vous devez deviner un nombre compris entre 0 et 1000

Votre nombre ? 512
512 est trop grand
Votre nombre ? 256
256 est trop grand
Votre nombre ? 128
128 est trop grand
Votre nombre ? 64
64 est trop grand
Votre nombre ? 32
32 est trop grand
Votre nombre ? 16
16 est trop petit
Votre nombre ? 24
Vous avez trouvé en 7 essais.
Remarques :
 ++nbr_trials est en fait +(+(nbr_trials)) -> aucun effet !

 Par défaut print() utilise le séparateur ' ', cela peut être modifié en définissant l’argument
optionnel sep.
7.1.2 Script whileDemo2.py

Le script :
"""
Sommes cumulées des valeurs positives paires lues
"""

__date__ = "21 juillet 2015"
sum_even = 0
i = int(input("Valeur entière <-1 pour terminer> ? "))
while i > 0:
sum_even += i if i % 2 == 0 else 0 # ternary operator
i = int(input("Valeur entière <-1 pour terminer> ? "))
print("Somme des valeurs cumulées paires:", sum_even)
Valeur entière <-1 pour terminer> ? 2

Valeur entière <-1 pour terminer> ? -1
Somme des valeurs cumulées paires: 10
Remarque :
 [on_true] if [expression] else [on_false] est l’opérateur ternaire correspondant

à [expression] ? [on_true] : [on_false] en C et Java.

7.1.3 Script noDoDemo.py

Le script :
"""
Lecture d'un nombre entier entre MIN et MAX
"""

__date__ = "21 juillet 2015"
MIN, MAX = 1, 10
nbr = -1
# while not(nbr>=MIN and nbr<=MAX):
while nbr < MIN or nbr > MAX: # short-circuiting of evaluation of logical expressions
nbr = int(input("Valeur entière entre " + str(MIN) + " et " + str(MAX) + " ? "))
print("Votre nombre:", nbr)
Valeur entière entre 1 et 10 ? 0

Votre nombre: 8
Remarques :
 Python pratique le « court-circuitage » d’expressions logiques (« lazy evaluation »).

 Il n’y a pas d’instruction do en Python (choix de l’orthogonalité…).

7.2 Structure répétitive for …

L’instruction for permet de parcourir une séquence (ou un objet itérable) en assignant à une variable de contrôle
les valeurs de cette séquence.
Syntaxe :
"for" target_list "in" expression_list ":" suite

["else" ":" suite]
Voici un extrait de la définition de la syntaxe telle que présentée dans la documentation Python
(https://docs.python.org/3/reference/compound_stmts.html#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.
7.2.1 Script forDemo.py

Le script :
"""
Exemples simples d'utilisation de my_list'instruction for
"""

__date__ = "13 août 2015"
import time
s = "Hello"
for c in s:
print(c, ord(c), sep=':', end=' - ')
print()

t = ('un', 2, (3, 'trois'))

for e in t:
print(e, end=' ')
print()
my_list = [1, 2, 3, 4]
for e in my_list: # e=my_list[0], e=my_list[1], ...
e = e + 10
print(my_list)
# my_list is not modified !
# e=my_list[0] e=e+10 -> my_list not modified
s = {'velo', 'voiture', 'train'}

for e in s:
print(e, end=' ')
print()
d = {'velo': 'bike', 'voiture': 'car', 'train': 'train'}

for k in d:
print(k, d[k], sep=':', end=' ')
print()
for i in range(5):
print(i, end=' ')
print()
for i in range(1, 20, 3):

print(i, end=' ')
print()
tic = time.process_time()
for i in range(100000000):
print(i, end=' ')
if i == 10:
break
print()
toc = time.process_time()
print(toc - tic)
tic = time.process_time()
for i in list(range(100000000)):
print(i, end=' ')
if i == 10:
break
print()
toc = time.process_time()
print(toc - tic)
str_ = "Hello"
for i, c in zip(range(len(str_)), str_):
print(i, " ", c, end=' , ')
print()

Un affichage :
H:72 - e:101 - l:108 - l:108 - o:111 -

un 2 (3, 'trois')
[1, 2, 3, 4]
voiture train velo
voiture:car train:train velo:bike
0 1 2 3 4
1 4 7 10 13 16 19
0 1 2 3 4 5 6 7 8 9 10
0.0006774046545617485
0 1 2 3 4 5 6 7 8 9 10
2.723252926476082
0 H , 1 e , 2 l , 3 l , 4 o ,
Remarques :
 La modification de la variable de contrôle e n’a pas modifié l’élément dans la liste (e est une
référence…) !
 range() fournit un itérateur, pas une séquence …
 La fonction zip() permet de parcourir plusieurs séquences en parallèle. Elle peut recevoir plus de
deux séquences, et elle s’arrête dès que la plus courte est épuisée. Elle renvoie un itérateur sur des
tuples.

8 LES EXCEPTIONS
Le script :
import locale
import time
def sqrt(x, eps=10 ** -12):

if not isinstance(x, int) and not isinstance(x, float):
raise TypeError(' must be an integer or a float')
if x < 0.0:
raise ValueError(' must be >= 0')
xp, xs = 0.0, 1.0
while abs(xs - xp) > eps:
xp = xs
xs = (xp + (x / xp)) / 2.0
return xs
print(sqrt(4))
try:
sr = sqrt(-4)
print('sqrt(-4) =', sr)
except TypeError:
print('Mauvais type')
except ValueError as e:
print('Mauvaise valeur:', e)
except: # do not use bare except : too broad exception clause
print('Autre problème')
finally:
print('Toujours effectué')
print('On continue')
f = None
try:
f = open('data.txt')
s = f.readline()
i = int(s.strip())
except (IOError, ValueError):
print('Le fichier data.txt ne peut pas être ouvert')
print('ou la première ligne ne contient pas un entier')
else:
print(i)
finally:
if f:
f.close()
locale.setlocale(locale.LC_ALL, '') # use user's preferred locale
print('Ctrl-C to arrêter le flux du temp!')

try:
while True:
print(time.strftime("%a, %d %b %Y %H:%M:%S"))
time.sleep(1)
except KeyboardInterrupt:
print("Cette façon d'arrêter une boucle est déconseillée...")
print('A+')

L’affichage :
2.0
Mauvaise valeur: must be >= 0
Toujours effectué
On continue
Le fichier data.txt ne peut pas être ouvert
ou la première ligne ne contient pas un entier
Ctrl-C to arrêter le flux du temp!
dim., 16 août 2015 09:15:54
dim., 16 août 2015 09:15:55
dim., 16 août 2015 09:15:56
dim., 16 août 2015 09:15:57
dim., 16 août 2015 09:15:58
Cette façon d'arrêter une boucle est déconseillée...
A+
Commentaires :
 Les exceptions permettent de délocaliser le traitement d’un problème par rapport à l’endroit dans le
code où celui-ci s’est manifesté.
 Elles permettent de bien séparer le code « normal » du code qui traite les cas exceptionnels.
 Permettent d’éviter de faire de nombreux tests (lisibilité et efficacité).
 Permettent de « rassembler » le traitement de nombreuses exceptions (cf. except (…, ...): ou
except:).
 Minimise les risques en cas d’oubli de traitement d’une condition exceptionnelle par le programmeur.
 La clause optionnelle else est exécutée si aucune exception n’a été lancée.
 La clause optionnelle finally est exécutée dans tous les cas (quand il y a ou qu’il n’y a pas
d’exception lancée).

9 LES TYPES DE DONNÉES NON SIMPLES

9.1 Chaîne de caractères
Les chaînes sont des séquences immuables de caractères.
Les littéraux de strings sont délimités par '…', "…", """…""" Les """ permettent de taper librement les
sauts de ligne sans devoir insérer des séquences d’échappement \n.
9.1.1 Script strings.py

Le script :
a = "bonjour"
b = """ici je mets
mon texte
sur plusieurs
lignes"""
print(b)
print(len(a))
print(a[0])
print(a[6])
print(a[-1]) # last character
print(a[-7])
# a[0]='B' # strings are immutable objects
a = 'B' + a[1:] # slicing
print(a)
print(a[2:6]) # slicing first included last excluded
print(a[:5])
print(a[2:])
print(a[::2]) # even characters
print(a[::-1]) # reverse order
s = 'trapézoïdal'
for car in a: # strings are sequences
print(car, ord(car), end=' , ')
print()
vowels = 'AaàâEeéèêëIiîïOoUuùYy'
for car in s:
if car in vowels: # test if an element is in a sequence
print(car, " est une voyelle.")
print('bonjour' < 'Bonjour')

print('mais' == 'maïs')
for i in range(32, 128):

print(chr(i), end="")
print()
s1 = 'abc'
s2 = 'abc'
print(s1 is s2) # some object can be reused because of immutability

L’affichage :
ici je mets
mon texte
sur plusieurs
lignes
7
b
r
r
b
Bonjour
njou
Bonjo
njour
Bnor
ruojnoB
B 66 , o 111 , n 110 , j 106 , o 111 , u 117 , r 114 ,
a est une voyelle.
é est une voyelle.
o est une voyelle.
ï est une voyelle.
a est une voyelle.
False
False
!"#$%&'()*+,-
./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
True
Remarques :
 L’opérateur in permet de tester si un élément appartient à une séquence.

 Les opérateurs relationnels ==, !=, <, >, <=, >= comparent les chaînes de caractères en utilisant
l’ordre de la codification unicode utf-8.
 Les objets de type str peuvent être « recyclés » car ils sont immuables !

9.2 Tuples
Les tuples sont des séquences immuables d’éléments pouvant être de types différents.
Les littéraux de tuples sont délimités par (), mais celles-ci peuvent être souvent omises (packing).
9.2.1 Script tuples.py

Le script :
t1 = 1, 'deux', 3.0
print(t1)
print(len(t1))
print(t1[::-1])
t2 = ('quatre', 5, 6)
t3 = t1 + t2
print(t3)
print(t3[2:5])
t4 = t1 * 3
print(t4)
# t4[0]='un' # tuples are immutables
for e in t4:
if type(e) is int: # test if type of e is exactly int
print(e)
for e in t4:
if isinstance(e, str): # test if type e is a str_ (ok if subclass)
print(e)
print((1, 2, 3) < (1, 2, 3, 4))
t = 1, 2, 3 # packing
print(t)
a, b, c = t # unpacking
print(a, b, c)
# a,b=t # too many values to unpack
t = 0, 'un', (2.1, 'two.two'), 3
print(t)
print(type(t[2]))
print(t[2][1])
t = (3) # not a tuple
print(t, type(t))
t = (3,) # a tuple
print(t, type(t))

L’affichage :
(1, 'deux', 3.0)

3
(3.0, 'deux', 1)
(1, 'deux', 3.0, 'quatre', 5, 6)
(3.0, 'quatre', 5)
(1, 'deux', 3.0, 1, 'deux', 3.0, 1, 'deux', 3.0)
1
1
1
deux
deux
deux
True
(1, 2, 3)
1 2 3
(0, 'un', (2.1, 'two.two'), 3)
<class 'tuple'>
two.two
3 <class 'int'>
(3,) <class 'tuple'>
Remarques :
 Les opérateurs de concaténation (+), de répétition (*), de test d’appartenance (in) ainsi que le slicing
([:]) fonctionnent comme avec les chaînes de caractères.
 Les opérateurs relationnels peuvent être utilisés avec les tuples.
9.3 Listes
Les listes sont des séquences muables d’éléments pouvant être de types différents.
Les littéraux de listes sont délimités par [].
9.3.1 Script lists.py

Le script :
my_list_1 = [1, 2, 3]
my_list_1[0] = 0
print(my_list_1)
my_list_1 = [2, 3, 5, 7]
empty = []
print(type(empty))
print(len(empty))
my_list_2 = ['gains', 'bar', 6, 9, (0, 1, 2), [0, 1, 2]]
print(my_list_2)
print(len(my_list_2))
print(type(my_list_2[4]))
print(type(my_list_2[5]))
print(my_list_2[-1])
print(my_list_2[2:4])
my_list_3 = my_list_1 + my_list_2
print(my_list_3)
print(my_list_1 * 3)
print(1 in my_list_1)
print(my_list_1 < [0, 1, 2])
my_list_4 = [0, 1, 2]
# my_list_4[1:1]=1 # 1 is not an iterable
my_list_4[1:1] = 'un' # insert an iterable before empty sequence 1:1
# insert ('u','n') !
print(my_list_4)
my_list_4[1:3] = ('ab', 'cd', 'ef') # replace with an iterable

# different lengths ok
print(my_list_4)
my_list_4[1:4] = ['u', 'n']
print(my_list_4)
my_list_4[4:4] = (3, 4)
print(my_list_4)
del my_list_4[4]
print(my_list_4)
del my_list_4[1:3]
print(my_list_4)
my_list_4.append(3)
print(my_list_4)
my_list_4.append((5, 6))
print(my_list_4)
my_list_4.extend((5, 6))
print(my_list_4)
my_list_4.extend([5, 6])
print(my_list_4)
my_list_4.insert(0, 'go')
print(my_list_4)
print(my_list_4[6][1])
print(my_list_4.count(6))
print(my_list_4.index(6))
my_list_4.remove(6)
print(my_list_4)
my_list_4.pop()
print(my_list_4)
my_list_1.reverse()
print(my_list_1)
my_list_1.sort()
print(my_list_1)
my_list = [0, 1, 2]
my_list.append(3)
my_list[len(my_list):len(my_list)] = [4]
my_list.insert(len(my_list), 5)
my_list.extend([6])
# my_list[len(my_list)]=7 # bad
print(my_list)
del my_list[0]
my_list[0:1] = []
print(my_list)
my_list[3:5] = [0, 1, 2, 3]
print(my_list)
del (my_list[3:6])
print(my_list)
my_list_1 = [0, 1, 2]
my_list_2 = my_list_1
print(my_list_2 is my_list_1)
my_list_1 = my_list_1 + [3] # create a new list !
my_list_1[0] = 9
print(my_list_1, my_list_2)
my_list_1 = [0, 1, 2]
my_list_2 = [0, 1, 2]
my_list = list(range(10)) # range is an iterator

print(my_list)
print(type(range(10)))

my_max = -1 # elements of my_list are positive

for e in my_list:
if e > my_max:
my_max = e
print(my_max)
L’affichage :
[0, 2, 3]
<class 'list'>
0
['gains', 'bar', 6, 9, (0, 1, 2), [0, 1, 2]]
6
<class 'tuple'>
<class 'list'>
[0, 1, 2]
[6, 9]
[2, 3, 5, 7, 'gains', 'bar', 6, 9, (0, 1, 2), [0, 1, 2]]
[2, 3, 5, 7, 2, 3, 5, 7, 2, 3, 5, 7]
False
False
[0, 'u', 'n', 1, 2]
[0, 'ab', 'cd', 'ef', 1, 2]
[0, 'u', 'n', 1, 2]
[0, 'u', 'n', 1, 3, 4, 2]
[0, 'u', 'n', 1, 4, 2]
[0, 1, 4, 2]
[0, 1, 4, 2, 3]
[0, 1, 4, 2, 3, (5, 6)]
[0, 1, 4, 2, 3, (5, 6), 5, 6]
[0, 1, 4, 2, 3, (5, 6), 5, 6, 5, 6]
['go', 0, 1, 4, 2, 3, (5, 6), 5, 6, 5, 6]
6
2
8
['go', 0, 1, 4, 2, 3, (5, 6), 5, 5, 6]
['go', 0, 1, 4, 2, 3, (5, 6), 5, 5]
[7, 5, 3, 2]
[2, 3, 5, 7]
[0, 1, 2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
[2, 3, 4, 0, 1, 2, 3]
[2, 3, 4, 3]
True
False
[9, 1, 2, 3] [0, 1, 2]
False
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
<class 'range'>
9
Remarques :
 Les opérateurs de concaténation (+), de répétition (*), de test d’appartenance (in) fonctionnent comme
avec les chaînes de caractères.
 Le slicing ([:]) est utilisable et permet de modifier, supprimer, insérer.
 Les opérateurs relationnels peuvent être utilisés avec les listes.
 Les listes peuvent être utilisées comme des piles grâce aux fonctions append() et pop() (opérations
agissant sur la fin de la liste).
 Les listes peuvent être utilisées comme des files mais, attention, les opérations d’insertion et de
suppression en tête de liste ne sont pas rapides (contrairement à ces mêmes opérations en fin de liste).

9.3.2 Copies de listes, script listCopy.py

Une copie effectuée au moyen une affectation telle que v=u[:] est une copie superficielle (shallow copy) : les
références dans u sont copiées, pas les objets référencés !
Pour dupliquer totalement la structure, on peut employer la fonction deepcopy() du module copy. Cette
fonction gère même les références cycliques !
Le script :
from copy import deepcopy
u = [0, 1, [21, 22]]

v = u[:] # shallow copy, the reference to [21,22] is copied !
print(u, v)
print(v is u)
print(v[2] is u[2])
u[0] = 3
u[2][0] = 4
print(u, v)
u = [0, 1, [21, 22]]

v = deepcopy(u)
print(u, v)
print(v is u)
print(v[2] is u[2])
u[0] = 3
u[2][0] = 4
print(u, v)
u = [10, 11, 12]

v = [20, 21, 22]
u[0] = v
v[0] = u
print(u, v)
w = deepcopy(v)
print(w)
print(w[0] is u)
w[0][1] = 1111
print(w)
w[0][0][1] = 2211
print(w)
print(u)
L’affichage :
[0, 1, [21, 22]] [0, 1, [21, 22]]
False
True
[3, 1, [4, 22]] [0, 1, [4, 22]]
[0, 1, [21, 22]] [0, 1, [21, 22]]
False
False
[3, 1, [4, 22]] [0, 1, [21, 22]]
[[[...], 21, 22], 11, 12] [[[...], 11, 12], 21, 22]
[[[...], 11, 12], 21, 22]
False
[[[...], 1111, 12], 21, 22]
[[[...], 1111, 12], 2211, 22]
[[[...], 21, 22], 11, 12]

9.3.3 Listes en compréhension, script listComprehension.py
La compréhension de listes (list comprehension) est une méthode concise pour créer des listes.
Une utilisation courante de cette méthode consiste à créer une liste à partir d’opérations appliquées à tous les
éléments d’une autre séquence ou d’un objet itérable ou à créer une sous-séquence des éléments satisfaisant une
certaine condition.
Le script :
# from The Python Tutorial from python.org
squares = [x ** 2 for x in range(10)]

print(squares)
squares = []
for x in range(10):
squares.append(x ** 2)
print(squares)
combs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

print(combs)
combs = []
for x in [1, 2, 3]:
for y in [3, 1, 4]:
if x != y:
combs.append((x, y))
print(combs)
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]]
transposed = [[row[i] for row in matrix] for i in range(4)]
print(transposed)
transposed = []
for i in range(4):
# the following 3 lines implement the nested list comprehension
transposed_row = []
for row in matrix:
transposed_row.append(row[i])
transposed.append(transposed_row)
print(transposed)
L’affichage :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

9.4 Ensembles
Les sets sont des collections non ordonnées muables d’éléments non dupliqués pouvant être de types différents.
Les éléments de l’ensemble doivent être des objets « hashables » (int, float, str, tuple,… mais pas
list, set, dict, …).
Les littéraux d’ensembles sont délimités par {}.
Les opérations mathématiques d’union, d’intersection, de différence sont réalisables.
Le type set est itérable.
9.4.1 Script sets.py

Le script :
words = {'hand', 'head', 'hand', 'head', 'foot', 'head'}

print(words)
print('head' in words)
print('buik' in words)
s1 = set('alabama')
s2 = set('alaska')
print(s1)
print(s2)
print(s1 - s2)
print(s1 | s2)
print(s1 & s2)
print(s1 ^ s2)
my_list = list(s1 & s2)
print(my_list)
my_list = set({}) # my_list={} creates a dictionary!
print(my_list)
for e in s1:
print(e)
L’affichage :
{'head', 'foot', 'hand'}
True
False
{'l', 'b', 'a', 'm'}
{'l', 'a', 's', 'k'}
{'b', 'm'}
{'l', 's', 'm', 'b', 'a', 'k'}
{'l', 'a'}
{'s', 'm', 'b', 'k'}
['l', 'a']
set()
l
b
a
m

9.5 Dictionnaires
Les dictionnaires sont des séquences modifiables où les « indices » (les clés) ne sont pas forcément des entiers.
A chaque clé (unique) correspond une valeur.
Les clés doivent être des objets « hashables » (donc non modifiables) (int, float, str, tuple,… mais pas
list, set, dict, …).
Même s’il existe une notion d’ordre sur les clés, cet ordre n’est généralement pas prévisible du point de vue du
programmeur ().
Tout comme les littéraux d’ensemble, les littéraux de dictionnaires sont délimités par {} , mais on utilise la
syntaxe clé:valeur pour définir les paires :
dict_display ::= "{" [key_datum_list | dict_comprehension] "}"

key_datum_list ::= key_datum ("," key_datum)* [","]
key_datum ::= expression ":" expression
9.5.1 Script dictionaries.py

Le script :
my_dico = {'one': 'un', 'two': 'deux', 'three': 'trois'}

print(my_dico)
print(type(my_dico))
print(my_dico['two'])
# print(my_dico['four']) # exception
my_dico[4] = 'quatre' # add the pair 4:'quatre'
print(my_dico)
my_dico[(6, 6)] = 66
print(my_dico)
# my_dico[[7,7]]=66 # the key must be a hashable type !
print(hash((6, 6)))
# print(hash([7,7])) # mutable objects are not hashable !
print(my_dico.keys()) # list of keys

print(my_dico.values())
for a, f in my_dico.items():
print(a, ':', f, end=',')
print()
print(my_dico.setdefault('two', 'twee'))
print(my_dico)
print(my_dico.setdefault('five', 'cinq'))
print(my_dico)
my_dico.update(((4, 'four'), (5, 'cinq')))

print(my_dico)
# print(my_dico.pop('six')) # exception
print(my_dico.pop('six', None))
print(my_dico.pop('one', None))
while my_dico:
c, v = my_dico.popitem() # arbitrary pair
print(c, v)
print(my_dico)

my_graph = {'Bruxelles': {'Charleroi': 30, 'Liège': 100, 'Mons': 50},

'Mons': {'Charleroi': 25, 'Bruxelles': 50},
'Namur': {'Liège': 40},
'Liège': {'Bruxelles': 101, 'Namur': 40},
'Charleroi': {'Bruxelles': 30, 'Mons': 40}}
print(my_graph)
print(my_graph['Bruxelles']['Mons'])
print(len(my_graph))
print('Enhet' in my_graph)
for t1 in my_graph:
for t2 in my_graph[t1]:
# lazy evaluation ...
if t2 in my_graph and t1 in my_graph[t2] and my_graph[t1][t2] ==
my_graph[t2][t1]:
print('Symétrie pour', t1, t2)
my_graph2 = my_graph.copy() # shallow copy !

print(my_graph2)
my_graph2.clear()
print(my_graph2)
t = set(my_graph.keys())
for t1 in my_graph:
t = t | set(my_graph[t1].keys())
print("{0:10s}".format(''), end='')
for t2 in t:
print("{0:10s}".format(t2), end='')
print()
for t1 in t:
print("{0:10s}".format(t1), end='')
for t2 in t:
d = my_graph.get(t1, {}).get(t2, 0)
print("{0:<10.2f}".format(d), end='')
print()

L’affichage :
{'three': 'trois', 'one': 'un', 'two': 'deux'}
<class 'dict'>
deux
{'three': 'trois', 4: 'quatre', 'one': 'un', 'two': 'deux'}
{'three': 'trois', 4: 'quatre', 'one': 'un', 'two': 'deux', (6, 6): 66}
3713087044579978631
dict_keys(['three', 4, 'one', 'two', (6, 6)])
dict_values(['trois', 'quatre', 'un', 'deux', 66])
three : trois,4 : quatre,one : un,two : deux,(6, 6) : 66,
deux
{'three': 'trois', 4: 'quatre', 'one': 'un', 'two': 'deux', (6, 6): 66}
cinq
{4: 'quatre', (6, 6): 66, 'three': 'trois', 'five': 'cinq', 'one': 'un', 'two': 'deux'}
{4: 'four', 5: 'cinq', (6, 6): 66, 'three': 'trois', 'five': 'cinq', 'one': 'un', 'two':
'deux'}
None
un
4 four
5 cinq
(6, 6) 66
three trois
five cinq
two deux
{}
{'Namur': {'Liège': 40}, 'Charleroi': {'Bruxelles': 30, 'Mons': 40}, 'Bruxelles':
{'Liège': 100, 'Mons': 50, 'Charleroi': 30}, 'Mons': {'Bruxelles': 50, 'Charleroi': 25},
'Liège': {'Namur': 40, 'Bruxelles': 101}}
50
5
False
Symétrie pour Namur Liège
Symétrie pour Charleroi Bruxelles
Symétrie pour Bruxelles Mons
Symétrie pour Bruxelles Charleroi
Symétrie pour Mons Bruxelles
Symétrie pour Liège Namur
{'Namur': {'Liège': 40}, 'Liège': {'Namur': 40, 'Bruxelles': 101}, 'Bruxelles': {'Liège':
100, 'Mons': 50, 'Charleroi': 30}, 'Mons': {'Bruxelles': 50, 'Charleroi': 25},
'Charleroi': {'Bruxelles': 30, 'Mons': 40}}
{}
Namur Mons Charleroi Liège Bruxelles
Namur 0.00 0.00 0.00 40.00 0.00
Mons 0.00 0.00 25.00 0.00 50.00
Charleroi 0.00 40.00 0.00 0.00 30.00
Liège 40.00 0.00 0.00 0.00 101.00
Bruxelles 0.00 50.00 30.00 100.00 0.00
Remarques :
 La fonction setdefault(key[,default]) renvoie la valeur associée à key si key est déjà

présent dans le dictionnaire, sinon la paire key:value est ajoutée au dictionnaire et value est
renvoyé. La valeur par défaut de default est None.
 La fonction update() permet de mettre à jour un dictionnaire en modifiant les valeurs associées aux
clés présentes et en ajoutant des paires clé:valeur lorsque les clés ne sont pas présentes.
 La fonction pop(key[,default]) utilisée avec un seul argument retire la paire correspondante si la
clé est présente et renvoie la valeur qui y était associée. Elle lance une exception dans le cas contraire.
La fonction pop() utilisée avec deux argument (la clé et une valeur par défaut) retire la paire si la clé
est présente et renvoie la valeur qui y était associée, sinon elle renvoie la valeur par défaut.
 La fonction get(key[,default]) renvoie la valeur associée à la clé si celle-ci est présente, sinon
default (ou None si default n’est pas fourni) (pas d’exception !).

10 LES CONVERSIONS DE TYPE

10.1 Script transtypage.py
Le script :
print(int())
print(int('123'))
print(int(9.9))
print(int(-9.9))
print(int('FFFF', 16))
print(float())
print(float(12345678901234567890))
print(float('+1.23'))
print(float(' -12345\n'))
print(float('1e-003'))
print(float('-Infinity'))
print(float('NaN'))
print(float('inf'))
print(bool())
print(bool(3))
print(bool(0))
print(bool(0.2))
print(bool((1, 2)))
print(bool(()))
print(bool([1, 2]))
print(bool([]))
print(bool({}))
print(str())
print(str('truc'))
print(str(12))
print(str(12.3))
print(str(True))
print(str((1, 2, 3)))
print(str([1, 2, 3]))
print(str({1, 2, 3}))
print(str({'un': 1, 2: 'deux'}))
print(str(range(10, 0, -2)))
print(tuple())
print(tuple('abc'))
print(tuple((1, 2, 3)))
print(tuple([1, 2, 3]))
print(tuple({1, 2, 3}))
print(tuple({'un': 1, 2: 'deux'}))
print(tuple(range(10, 0, -2)))
print(list())
print(list('abc'))
print(list((1, 2, 3)))
print(list([1, 2, 3]))
print(list({1, 2, 3}))
print(list({'un': 1, 2: 'deux'}))
print(list(range(10, 0, -2)))

print(set())
print(set('abc'))
print(set((1, 2, 3)))
print(set([1, 2, 3]))
print(set({1, 2, 3}))
print(set({'un': 1, 2: 'deux'}))
print(set(range(10, 0, -2)))
print(dict())
print(dict((('two', 2), ('one', 1), ('three', 3))))
print(dict({('two', 2), ('one', 1), ('three', 3)}))
print(dict([('two', 2), ('one', 1), ('three', 3)]))
print(dict({'three': 3, 'one': 1, 'two': 2}))
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))
L’affichage :
0
123
9
-9
65535
0.0
1.2345678901234567e+19
1.23
-12345.0
0.001
-inf
nan
inf
False
True
False
True
True
False
True
False
False
truc
12
12.3
True
(1, 2, 3)
[1, 2, 3]
{1, 2, 3}
{2: 'deux', 'un': 1}
range(10, 0, -2)
()
('a', 'b', 'c')
(1, 2, 3)
(1, 2, 3)
(1, 2, 3)
(2, 'un')
(10, 8, 6, 4, 2)
[]
['a', 'b', 'c']
[1, 2, 3]
[1, 2, 3]
[1, 2, 3]
[2, 'un']
[10, 8, 6, 4, 2]
set()
{'a', 'b', 'c'}
{1, 2, 3}
{1, 2, 3}

{1, 2, 3}
{2, 'un'}
{8, 10, 2, 4, 6}
{}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}

11 LES FONCTIONS
11.1 Script fibFctDemo.py
Le script :
def show_fibonacci(n, i0=0, i1=1):

"""Print a Fibonacci series up to n and beginning with i0 and i1."""
for i in range(n):
print(i0, end=' ')
i0, i1 = i1, i0 + i1
print()
show_fibonacci(10)
show_fibonacci(10, i1=2)
show_fibonacci(10, 1, 3)
show_fibonacci(10, i1=3, i0=1)
print(show_fibonacci(10)) # function return None
def compute_fibonacci(n, i0=0, i1=1):

"""Return a Fibonacci series up to n and beginning with i0 and i1."""
r = []
for i in range(n):
r.append(i0)
i0, i1 = i1, i0 + i1
return r
fs = compute_fibonacci(8)
print(fs)
L’affichage :
0 1 1 2 3 5 8 13 21 34
0 2 2 4 6 10 16 26 42 68
1 3 4 7 11 18 29 47 76 123
1 3 4 7 11 18 29 47 76 123
0 1 1 2 3 5 8 13 21 34
None
[0, 1, 1, 2, 3, 5, 8, 13]
Commentaires :
 Le mot clé def introduit la définition d’une fonction.

 Les paramètres obligatoires peuvent être suivis de paramètres optionnels qui proposent des valeurs par
défaut.
 Lors de l’appel, on peut nommer les arguments (keyword arguments), ce qui donne de la liberté quant à
leur ordre d’écriture.
 La première déclaration dans le corps de la fonction peut être un littéral de chaîne de caractères qui sert
de docstring (tester dans un shell Python import fibFctDemo suivi de
help(fibFctDemo.show_fibonacci)).
 L’exécution de la fonction provoque la création d’une nouvelle table des symboles utilisée pour les
variables locales de la fonction (cf. contexte de pile). Toute assignation de variable dans la fonction
ajoute la variable dans la table locale si elle n’est pas déjà présente. Toute référence à une variable dans
la fonction provoque une recherche dans la table locale, puis dans les tables locales des fonctions
englobantes, puis dans la table des symboles globale, puis finalement dans la table des noms prédéfinis.
 Si la fonction ne renvoie explicitement de valeur, c’est la valeur None qui est renvoyée.
 Il est possible de tester les fonctions du script dans un shell en n’oubliant pas d’importer le script et de
préfixer le nom de la fonction.
11.2 Script gcd.py

Le script :
def gcd(a, b):

"""
Renvoie le plus grand commun diviseur des 2 valeurs entières reçues.
"""
a, b = abs(a), abs(b)
while b != 0:
a, b = b, a % b
return a
Un test dans un shell Python :

>>> import gcd
>>> help(gcd.gcd)
Help on function gcd in module gcd:
gcd(a, b)
Renvoie le plus grand commun diviseur des 2 valeurs entières reçues.
>>> print(gcd(12,30))
File "<console>", line 0, in <module>
TypeError: 'module' object is not callable
>>> print(gcd.gcd(12,30))
6
>>> a,b=12,30
>>> print(gcd.gcd(a,b))
6
>>> print(a,b)
12 30
Remarque :
 Les arguments sont passés par valeur (par copie). Donc, ce sont des copies des références a et b qui sont
transmises à la fonction. Il y a des variables a et b dans la table des symboles du shell et deux autres
variables a et b dans la table des symboles locale à cet appel à gcd. Juste après l’appel le a du shell et
le a local désignent un même objet « 12 » mais les affectations aux variables locales a et b n’ont pas
d’incidence sur les variables du shell ! Remarquons également que les objets utilisés ne sont pas
modifiables.

11.3 Script badSwap.py

Le script :
def bad_swap(x, y):

"""
Fail to swap arguments.
"""
x, y = y, x
a, b = 1, 2
bad_swap(a, b)
print(a, b)
def swap(a, b):

"""
Return a tuple of the two arguments swapped.
"""
return b, a
a, b = swap(a, b)
print(a, b)
L’affichage :
1 2
2 1
Remarque :
 Les arguments, qui sont des références, sont passés par valeur (par copie)…

11.4 Script sumPolymorph.py

Le script :
def do_sum(a, b):

"""
Renvoie la somme des arguments lorsque celle-ci fait sens.
"""
return a + b
print(do_sum(1, 2))
print(do_sum(1.1, 2.2))
print(do_sum('ab', 'cd'))
print(do_sum(True, True)) # True -> 1
print(do_sum('ab', 3)) # exception
L’affichage :
3
3.3000000000000003
abcd
2
File
"D:\users\jean\Documents\Ann_2223\isib\python\2ZZ1303\syllabus\demos\sumPolymorph.py",
line 15, in <module>
print(do_sum('ab', 3)) # exception
File
"D:\users\jean\Documents\Ann_2223\isib\python\2ZZ1303\syllabus\demos\sumPolymorph.py",
line 7, in do_sum
return a + b
TypeError: can only concatenate str (not "int") to str
Remarques :
 Python utilise un typage dynamique fort, ce qui permet des comportements polymorphes (dynamiques)
de fonctions.
 Il est impératif en Python de bien contrôler les types des objets que l’on manipule et de gérer les
éventuelles erreurs de type possibles (cf. gestion des exceptions).

11.5 Script gatherScatterKwargs.py

Le script :
def g(required1, required2, optional1=0, optional2=1, *args, **kwargs):

print('required1:', required1)
print('required2:', required2)
print('optional1:', optional1)
print('optional2:', optional2)
print('args:', args)
for keyword in kwargs:
print(keyword, ' : ', kwargs[keyword])
g(1, 2)
g(1, 2, 3)
g(1, 2, 3, 4)
# positional argument must precede keyword argument
g(1, 2, 3, 4, 'big', 'bang', truc=7, bidule=8)
g(1, 2, optional2=3, truc=7, optional1=4, bidule=8)
t = (19, 5)
print(divmod(*t))
L’affichage :
required1: 1
required2: 2
optional1: 0
optional2: 1
args: ()
required1: 1
required2: 2
optional1: 3
optional2: 1
args: ()
required1: 1
required2: 2
optional1: 3
optional2: 4
args: ()
required1: 1
required2: 2
optional1: 3
optional2: 4
args: ('big', 'bang')
truc : 7
bidule : 8
required1: 1
required2: 2
optional1: 4
optional2: 3
args: ()
truc : 7
bidule : 8
(3, 4)

Commentaires :
 Il est possible de créer des fonctions qui admettent un nombre variable d’arguments en utilisant un
paramètre dont le nom commence par * et qui rassemble (gather) les arguments en un tuple.
 Il ne peut y avoir qu’un seul paramètre « gather » et il doit après les arguments positionels.
 Les paramètres optionnels doivent venir après les paramètres requis.
 Lorqu’un paramètre de type **param est présent ; il collecte dans un dictionnaire tous les arguments
nommés (« keyword argument » de forme key=value) qui ne correspondent pas à des paramètres.
 L’opérateur * appliqué à un tuple lors de l’appel à une fonction permet de « transformer » le tuple en
une suite d’arguments (scatter).
11.6 Script rectIntegration.py

Le script :
import math
def rect_integration(func, bi=0.0, bs=1.0, n=100):

"""
Calcule l'intégrale de func de a à b par la méthode des rectangles avec n
intervalles.
"""
step = (bs - bi) / n
x = bi + step / 2.0
my_sum = 0.0
for i in range(n):
my_sum += func(x) * step
# print(i,x,sum)
x += step
return my_sum
print(rect_integration(math.cos, 0, math.pi / 2.0))

print(rect_integration(math.cos, 0, math.pi / 2.0, 1000))
print(rect_integration(math.cos, bs=math.pi / 2.0))
print(rect_integration(math.cos, n=10000, bs=math.pi / 2.0))
f = lambda x: x ** 3 - 3.0 * x ** 2 + 2 * x + 1
print(rect_integration(f, -1.0, 1.0, 1000))
print(rect_integration(lambda y: y ** 3 - y, -1.0, 1.0, 1000))
L’affichage :
1.000010280911905
1.000000102808391
1.000010280911905
1.0000000010279895
2.0000000021829813e-06
-1.7968109910105473e-16
Commentaires :
 Python permet de transmettre des fonctions à des fonctions.

 Le mot clé lambda permet de créer une expression (et non une instruction) qui renvoie un objet fonction.

11.7 Script scope.py

Le script :
def f(b): # this name is local

global a
a = 11
b = 12
c = 13 # this name is local
print(a, b, c, d) # no local d -> global d used
a, b, c, d = 1, 2, 3, 4
print(a, b, c, d)
f(b)
print(a, b, c, d)
def outer():
x = 11
def inner():
y = 22
print('inner->', x, y, z) # rule local-> enclosed -> global -> built-in
print('outer->', x, y, z)
inner()
print('outer->', x, y, z)
x, y, z = 1, 2, 3
print('global->', x, y, z)
outer()
print('global->', x, y, z)
L’affichage :
1 2 3 4
11 12 13 4
11 2 3 4
global-> 1 2 3
outer-> 11 2 3
inner-> 11 22 3
outer-> 11 2 3
global-> 1 2 3
Commentaires :
 Le mot clé global permet de signaler dans une fonction que l’on veut utiliser une variable globale de
nom donné.
 L’exécution de la fonction provoque la création d’une nouvelle table des symboles utilisée pour les
variables locales de la fonction (cf. contexte de pile). Toute assignation de variable dans la fonction
ajoute la variable dans la table locale si elle n’est pas déjà présente. Toute référence à une variable dans
la fonction provoque une recherche dans la table locale, puis dans les tables locales des fonctions
englobantes, puis dans la table des symboles globale, puis finalement dans la table des noms prédéfinis.

12 LES FICHIERS
12.1 Script files.py
Le script :
import random
import os
os.chdir("./data")
myFile = open('data.txt', 'w') # creation mode

myFile.write('Ceci est\nun fichier texte\n')
myFile.close()
myFile = open('data.txt', 'a') # append mode

myFile.write('àäâéèëêùç\n')
myFile.write(str(123.45) + '\n')
myFile.write(str([1, 2, 3]) + '\n')
myFile.close()
itf = open('data.txt', 'r')

st = itf.read()
print(st)
itf.close()

s = itf.read(10)
while s:
print(s)
s = itf.read(10)
itf.close()

s = itf.readline()
while s:
print(s, end='')
s = itf.readline()
itf.close()

my_list = itf.readlines()
print(my_list)
itf.close()
size = os.stat('data.txt').st_size
print(size)
# should use true random cryptage phrase
random.seed(19856325475123052585)
rba = bytearray(random.getrandbits(8) for i in range(size)) # generator object
print('Key:', rba)

# encrypt
BUFF_SIZE = 4 # should be greather
bf = open('data.txt', 'rb+')
i = 0
while True:
b = bf.read(BUFF_SIZE)
if not b:
break
ln = len(b)
eba = bytearray(b[j] ^ rba[i + j] for j in range(ln)) # XOR
bf.seek(-ln, 1) # from_what: 0,1,2 (begin,current,enb)
bf.write(eba)
i += ln
bf.seek(0, 0)
print('Encrypted file:', bf.read())
bf.close()
# decrypt
bf = open('data.txt', 'rb+')
i = 0
while True:
b = bf.read(BUFF_SIZE)
if not b:
break
ln = len(b)
eba = bytearray(b[j] ^ rba[i + j] for j in range(ln))
bf.seek(-ln, 1) # from_what: 0,1,2 (begin,current,enb)
bf.write(eba)
i += ln
bf.seek(0, 0)
print('Decrypted file:', bf.read())
itf.close()

for line in itf:
print(line, end='')
itf.close()
itf = open('data.txt', 'r', encoding='cp1252')

otf = open('data_utf8.txt', 'w', encoding='utf-8')
for line in itf:
otf.write(line)
otf.close()
itf.close()
cd = os.getcwd()
print(cd)
def dir_walk(dirname):
for name in os.listdir(dirname):
path = os.path.join(dirname, name)
if os.path.isfile(path):
print(path)
else:
dir_walk(path)
dir_walk(cd + '\\..')

Un affichage :
Ceci est
un fichier texte
àäâéèëêùç
123.45
[1, 2, 3]
Ceci est
u
n fichier
texte
àäâé
èëêùç
123.
45
[1, 2,
3]
Ceci est
un fichier texte
àäâéèëêùç
123.45
[1, 2, 3]
['Ceci est\n', 'un fichier texte\n', 'àäâéèëêùç\n', '123.45\n', '[1, 2, 3]\n']
58
Key:
bytearray(b"{8\xc9\x9f\xbf\x95{\x93E$m\xf4\xe2s\x07\x8ae\x8f\xd9\xee\xc89\xc21!N\xf7\x8e\
xfa\xc1l\xd2\xc67\xfc\x84\xa4\xeeg\xf4\xb2k\x8dW\x11\x06w\xea\x18\x03U\'\xd0\x8bnjw\xdf")
Encrypted file:
b'8]\xaa\xf6\x9f\xf0\x08\xe7H.\x18\x9a\xc2\x15n\xe9\r\xe6\xbc\x9c\xe8M\xa7IU+\xfa\x84\x1a
%\x8e;.\xdc\x16}C\xe3m\xc5\x80X\xa3c$\x0b}\xb1)/u\x15\xfc\xab]7z\xd5'
Decrypted file: b'Ceci est\r\nun fichier
texte\r\n\xe0\xe4\xe2\xe9\xe8\xeb\xea\xf9\xe7\r\n123.45\r\n[1, 2, 3]\r\n'
Ceci est
un fichier texte
àäâéèëêùç
123.45
[1, 2, 3]
D:\Ann_1516\isib\python\5IN0304\data
D:\Ann_1516\isib\python\5IN0304\data\..\badPermut.py
D:\Ann_1516\isib\python\5IN0304\data\..\data\data.txt
D:\Ann_1516\isib\python\5IN0304\data\..\data\data_utf8.txt
D:\Ann_1516\isib\python\5IN0304\data\..\data\words.txt
D:\Ann_1516\isib\python\5IN0304\data\..\dictionaries.py
D:\Ann_1516\isib\python\5IN0304\data\..\exceptions.py
D:\Ann_1516\isib\python\5IN0304\data\..\fibFctDemo.py
D:\Ann_1516\isib\python\5IN0304\data\..\files.py
D:\Ann_1516\isib\python\5IN0304\data\..\forDemo.py
D:\Ann_1516\isib\python\5IN0304\data\..\gatherAndScatter.py
D:\Ann_1516\isib\python\5IN0304\data\..\gcd.py
D:\Ann_1516\isib\python\5IN0304\data\..\ifDemo.py
D:\Ann_1516\isib\python\5IN0304\data\..\integRect.py
D:\Ann_1516\isib\python\5IN0304\data\..\listComprehension.py
D:\Ann_1516\isib\python\5IN0304\data\..\listCopy.py
D:\Ann_1516\isib\python\5IN0304\data\..\lists.py
D:\Ann_1516\isib\python\5IN0304\data\..\noDoDemo.py
D:\Ann_1516\isib\python\5IN0304\data\..\prog1.py
D:\Ann_1516\isib\python\5IN0304\data\..\prog2.py
D:\Ann_1516\isib\python\5IN0304\data\..\scope.py
D:\Ann_1516\isib\python\5IN0304\data\..\sets.py
D:\Ann_1516\isib\python\5IN0304\data\..\shell.py
D:\Ann_1516\isib\python\5IN0304\data\..\strings.py
D:\Ann_1516\isib\python\5IN0304\data\..\sumPolymorph.py
D:\Ann_1516\isib\python\5IN0304\data\..\transtypage.py
D:\Ann_1516\isib\python\5IN0304\data\..\tuples.py
D:\Ann_1516\isib\python\5IN0304\data\..\whileDemo1.py
D:\Ann_1516\isib\python\5IN0304\data\..\whileDemo2.py

Commentaires :
 open(filename,mode) ouvre un fichier de nom donné dans le mode demandé. mode peut être
'r' (lecture), 'w' (écriture), 'a' (ajout), 'r+' (lecture/écriture). Si on ajoute b au mode, le
fichier est ouvert en mode binaire (les lectures et écritures utilisent des objets bytes et non plus des
str). mode est optionnel et la valeur par défaut est 'r'. Le paramètre optionnel encoding permet
de définir l’encodage du fichier
 f.read() renvoie tout le contenu du flux sous forme d’un objet str ou bytes suivant le mode
d’ouverture.
 f.read(size) renvoie un objet str ou bytes contenant maximum size éléments (caractères ou
bytes).
 f.readline() renvoie la ligne suivante du flux (mode texte) ou une chaîne vide en cas de fin de
fichier.
 f.readlines() renvoie la liste des lignes dans le flux
 f.write(string) ou f.write(bytes) écrit dans le flux les caractères ou les bytes et renvoie le
nombre d’éléments écrits.
 f.tell() renvoie la position courante en nombre de bytes depuis le début du fichier. N’a d’intérêt
que pour les fichiers binaires.
 f.seek(offset, from_what) définit la position du curseur. from_what peut être 0 (début), 1
(position courante) ou 2 (fin de fichier).
 f.close() permet de fermer le flux et de libérer les ressources système associées.
 Pour lire les lignes d’un fichier, il est possible, et efficace, de boucler sur l’objet flux
(for line in f:).

13 LA PROGRAMMATION FONCTIONELLE EN PYTHON

Références :
 https://docs.python.org/3/howto/functional.html
 https://docs.python.org/fr/3/glossary.html
 https://en.wikipedia.org/wiki/Functional_programming
13.1 Présentation
Python n’est pas un langage de programmation fonctionnelle mais permet d’écrire des fragments de code dans
un style « programmation fonctionnelle ».
La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui envisage la

programmation comme l’évaluation de fonctions mathématiques. Elle diffère en cela de la programmation
impérative (y compris la programmation orientée objet) qui met l’accent sur les instructions, les structures de
contrôles et l’état du programme (et/ou des objets).
Les principales caractéristique sont :
 Fonctions pures :
Le code est idempotent c.-à-d. que la valeur de retour d’une fonction ne dépend que de ses arguments
(on parle également de transparence référentielle).
Les fonctions n’ont pas d’effet de bord (mémoire ou E/S).
Elles n’ont pas d’état « externe » (pas d’usage de variables globales ou de variables membres de la
classe ou de l’objet qui les contiendraient).
 Objets de première classe :
Les fonctions sont des objets manipulables.
 Fonctions d’ordre supérieur :
Fonctions pouvant prendre des fonctions comme arguments (« callback ») ou renvoyer une fonction
comme résultat.
 Récursivité :
L’itération se fait de préférence par la récursivité.

13.2 Itérateurs (iterators)

Les itérateurs sont des objets capables de retourner un à un les éléments d’un flux (éventuellement infini). Un
itérateur Python possède une méthode __next()__ qui renvoie l’élément suivant. S’il n’y a plus d’élément,
une exception StopIteration est lancée.
La méthode prédéfinie iter() reçoit un objet et renvoie un itérateur si celui-ci est « itérable ». Dans le cas
contraire une exception TypeError. Les types prédéfinis suivants sont itérables : list, tuple, dict,
string, file.
>>> my_list = [1,2]

>>> it = iter(my_list)
>>> next(it)
1
>>> next(it)
2
>>> next(it)
File "<input>", line 1, in <module>
StopIteration
On peut parcourir la séquence produit par un itérateur avec l’instruction « for e in obj : … » qui est
équivalente à « for e in iter(obj) : … ».
for i in iter(obj):
print(i)
for i in obj:
print(i)
Les listes et les tuples proposent des constructeurs qui acceptent des itérateurs.
>>> my_list = [1, 2]

>>> iter = iter(my_list)
>>> t = tuple(iter)
>>> t
(1, 2)
Certaines fonctions prédéfinies acceptent des itérateurs comme arguments.
>>> my_tuple = [1, 2,3]

>>> it = iter(my_tuple)
>>> sum(it)
6
>>> min(it)
File "<input>", line 1, in <module>
ValueError: min() arg is an empty sequence
>>> min(it)
1
>>> max(it)
3

13.3 Expressions génératrices (generator expressions) et listes en

compréhension (list comprehensions)
L’expression suivante utilise les listes en compréhension et renvoie une liste :
>>> line_list = [' un\n', 'deux \n', ' trois ']

>>> stripped_line_list = [line.strip() for line in line_list]
>>> print(stripped_line_list)
['un', 'deux', 'trois']
Par contre l’expression suivante utilise une expression génératrice et renvoie un objet générateur :
>>> stripped_line_iter = (line.strip() for line in line_list)

>>> print(stripped_line_iter)
<generator object <genexpr> at 0x000001FB049BAD48>
>>> print('->'.join(stripped_line_iter))
un->deux->trois
13.4 Générateurs (generators)

Les générateurs sont des types particuliers de fonctions qui simplifient l’écriture d’itérateurs.
Exemple :
def fibonacci_generator(n): # we suppose n > 0

a = 0
yield a
n -= 1
b = 1
while n > 0:
yield b
n -= 1
b = a + b
a = b
for e in fibonacci_generator(4):
print(e, end=' ')
print()
print(sum(fibonacci_generator(100)))
Affichage :
0 1 1 2
316912650057057350374175801344

13.5 Small functions and the lambda expression

Lorsqu’on écrit du code dans un style « programmation fonctionelle », on a souvent besoin d’écrire de petites
fonctions (ou plutôt des objets fonctions) qui sont utilisées comme argument d’autres fonctions. Le mot clé
lambda permet de créer une expression (et non une instruction) qui renvoie un objet fonction.
Exemple :
f1 = lambda x: x + 1
print(f1(3))
f2 = lambda x, y: x * y
print(f2(2, 3))
def translate(func, t):

return lambda x: func(x - t)
def scale(func, s):

return lambda x: s * func(x)
new_func = scale(translate(f1, 3), 0.5)

print(new_func(0))
Affichage :
4
6
-1.0
13.6 Fonctions intégrées (built-in functions) et itérateurs
Référence : https://docs.python.org/3/library/functions.html
range(stop)
range(start, stop[, step])
Rather than being a function, range is actually an immutable sequence type, as documented in Ranges and Sequence Types
— list, tuple, range.
Exemple :
for i in range(5):
print(i, end=',')
print()
for i in range(1, 5):

print(i, end=',')
print()
for i in range(1, 7, 2):

print(i, end=',')
print()
for i in range(10, 2, -2):

print(i, end=',')
print()

Affichage :
0,1,2,3,4,
1,2,3,4,
1,3,5,
10,8,6,4,
enumerate(iterable, start=0)¶
Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports
iteration. The __next__() method of the iterator returned by enumerate() returns a tuple containing
a count (from start which defaults to 0) and the values obtained from iterating over iterable.
Exemple :
my_list = ["Tintin", "Milou", "Haddock"]

enu = enumerate(my_list)
print(type(enu))
for ele in enumerate(my_list):

print(ele, end=',')
print()
for count, ele in enumerate(my_list, 10):

print(count, ele, sep='-', end=', ')
print()
Affichage :
<class 'enumerate'>
(0, 'Tintin'),(1, 'Milou'),(2, 'Haddock'),
10-Tintin, 11-Milou, 12-Haddock,
filter(function, iterable)¶
Construct an iterator from those elements of iterable for which function returns true. iterable may be
either a sequence, a container which supports iteration, or an iterator. If function is None, the identity
function is assumed, that is, all elements of iterable that are false are removed.
Exemple :
ages = range(1, 30, 2)

mineurs = filter(lambda x: x < 18, ages)
print(mineurs)
print(list(mineurs))
Affichage :
<filter object at 0x00000184742B5C48>

[1, 3, 5, 7, 9, 11, 13, 15, 17]

iter(object[, sentinel])¶
Return an iterator object. The first argument is interpreted very differently depending on the presence of
the second argument. Without a second argument, object must be a collection object which supports the
iteration protocol (the __iter__() method), or it must support the sequence protocol (the
__getitem__() method with integer arguments starting at 0). If it does not support either of those
protocols, TypeError is raised. If the second argument, sentinel, is given, then object must be a callable
object. The iterator created in this case will call object with no arguments for each call to its __next__()
method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value
will be returned.
Exemple :
for e in iter(lambda: random.randint(-5, 6), 0):

print(e, end=',')
print()
Affichage :
-1,-1,3,-4,5,-5,6,-4,1,1,-5,-3,-5,3,-2,-5,5,1,3,6,
map(function, iterable, ...)¶

Return an iterator that applies function to every item of iterable, yielding the results. If additional iterable
arguments are passed, function must take that many arguments and is applied to the items from all iterables
in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted.
Exemple :
my_list = [3, 2, 4]
my_iter = map(lambda x: '+-' * x, my_list)
for e in my_iter:
print(e, end=', ')
print()
my_list1 = [3, 2, 4]
my_list2 = [1, 2, 3]
my_iter = map(lambda x, y: x ** y, my_list1, my_list2)
for e in my_iter:
print(e, end=', ')
print()
Affichage :
+-+-+-, +-+-, +-+-+-+-,

3, 4, 64,

reversed(seq)¶
Return a reverse iterator. seq must be an object which has a __reversed__() method or supports the
sequence protocol (the __len__() method and the __getitem__() method with integer arguments
starting at 0).
Exemple :
my_anacyclic = 'l''ami naturel'

print(list(reversed(my_anacyclic)))
Affichage :
['l', 'e', 'r', 'u', 't', 'a', 'n', ' ', 'i', 'm', 'a', 'l']
zip(*iterables)¶
Make an iterator that aggregates elements from each of the iterables.
Returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument
sequences or iterables. The iterator stops when the shortest input iterable is exhausted. With a single
iterable argument, it returns an iterator of 1-tuples. With no arguments, it returns an empty iterator.
Exemple :
my_tuple1 = ('un', 'deux', 'trois')

my_tuple2 = ('one', 'two', 'three')
for e in zip(my_tuple1, my_tuple2):

print(e, end=',')
print()
print(dict(zip(my_tuple2, my_tuple1)))
Affichage :
('un', 'one'),('deux', 'two'),('trois', 'three'),

{'one': 'un', 'two': 'deux', 'three': 'trois'}
all(iterable)¶
Return True if all elements of the iterable are true (or if the iterable is empty).
any(iterable)¶
Return True if any element of the iterable is true. If the iterable is empty, return False.
Exemple :
# well, this give an infinite stream!

my_iter = iter(lambda: random.choice([True, False]), None)
# !!! lazy evaluation !!!
print(all(my_iter))
print(any(my_iter))
Affichage :
False
True

max(iterable, *[, key, default])¶

Return the largest item in an iterable.
There are two optional keyword-only arguments. The key argument specifies a one-argument ordering
function like that used for list.sort(). The default argument specifies an object to return if the
provided iterable is empty. If the iterable is empty and default is not provided, a ValueError is raised.
If multiple items are maximal, the function returns the first one encountered. This is consistent with other
sort-stability preserving tools such as sorted(iterable, key=keyfunc, reverse=True)[0]
and heapq.nlargest(1, iterable, key=keyfunc).
min(iterable, *[, key, default])¶

Return the smallest item in an iterable
There are two optional keyword-only arguments. The key argument specifies a one-argument ordering
function like that used for list.sort(). The default argument specifies an object to return if the
provided iterable is empty. If the iterable is empty and default is not provided, a ValueError is raised.
If multiple items are minimal, the function returns the first one encountered. This is consistent with other
sort-stability preserving tools such as sorted(iterable, key=keyfunc)[0] and
heapq.nsmallest(1, iterable, key=keyfunc).
Exemple :
print(min(['truc','machin','chose'],key=lambda x : len(x)))
print(max(['truc','machin','chose'],key=lambda x : len(x)))
print(max(range(0,0,1),default=float('Inf')))
Affichage :
truc
machin
inf
sum(iterable[, start])¶
Sums start and the items of an iterable from left to right and returns the total. start defaults to 0. The
iterable’s items are normally numbers, and the start value is not allowed to be a string.
For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a
sequence of strings is by calling ''.join(sequence). To add floating point values with extended
precision, see math.fsum(). To concatenate a series of iterables, consider using
itertools.chain().
Exemple :
print(sum(range(-1000,1000)))

Affichage :
-1000
sorted(iterable, *, key=None, reverse=False)¶

Return a new sorted list from the items in iterable.
Has two optional arguments which must be specified as keyword arguments.
key specifies a function of one argument that is used to extract a comparison key from each element in
iterable (for example, key=str.lower). The default value is None (compare the elements directly).
reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were
reversed.
The built-in sorted() function is guaranteed to be stable. A sort is stable if it guarantees not to change the
relative order of elements that compare equal — this is helpful for sorting in multiple passes (for example,
sort by department, then by salary grade).
Exemple :
my_list = [(1, 5), (2, 4), (4, 1), (3, 6)]

sorted_list = sorted(my_list, key=lambda pair: pair[1], reverse=True)
print(sorted_list)
Affichage :
[(3, 6), (1, 5), (2, 4), (4, 1)]
13.7 Le module itertools

Références : https://docs.python.org/fr/3/library/itertools.html
13.8 Le module functools

Références : https://docs.python.org/fr/3/library/functools.html

14 EXEMPLES
14.1 Exemple 1 : selectionSortDemo.py
Le script :

__date__ = "22 novembre 2021"
"""
Effectue un tri par sélection sur un tableau d'entiers entrés au
clavier.
"""
def read_list():
"""
Lit au clavier une liste d'entiers.
:return: Une liste contenant la liste des nombres entiers.
"""
my_list = []
s = input('Entrez la liste des entiers séparés par des espaces : ')
str_list = s.split()
for i, e in enumerate(str_list):
my_list.append(int(e))
return my_list
def show_list(_list):
"""
Lit au clavier une liste d'entiers.
:param _list: Une liste contenant la liste des nombres entiers à
afficher.
"""
for e in _list:
# print(i, _list[i])
print("{0:<8d}".format(e), end=' ')
print()

def sort(_list):
"""
Trie une liste d'entiers par la méthode du tri par sélection.
:param _list: Une liste contenant la liste des nombres entiers à
trier.
"""
last = len(_list) - 1
while last > 0:
maxi = 0
for i in range(1, last + 1):
if _list[i] > _list[maxi]:
maxi = i
_list[last], _list[maxi] = _list[maxi], _list[last]
last -= 1
# my_list = {9, 4, 3, 2, 1, 6, 5, 7, 8}
print("Tri par sélection\n")
my_list = read_list()
print("Avant : ")
show_list(my_list)
sort(my_list)
print("Après : ")
show_list(my_list)
Un affichage:
Tri par sélection
Entrez la liste des entiers séparés par des espaces : 2 7 4 3 2 1 8 9

Avant :
2 7 4 3 2 1 8 9
Après :
1 2 2 3 4 7 8 9
Process finished with exit code 0

14.2 Exemple 2 : package inout

14.2.1 Package inout
Le fichier __init__.py du dossier syllabus\lib\inout :
from .inout import read_int, read_float, stop
Le fichier inout.py du dossier syllabus\lib\inout :

__date__ = "13 octobre 2021"
import sys
def read_int(mini=-sys.maxsize - 1, maxi=sys.maxsize):

"""
Lit au clavier un entier de type <tt>int</tt> compris entre des
bornes.
La lecture est répétée si le format n'est pas valide ou si les
bornes ne sont pas respectées.
param min: la plus petite valeur autorisée

param max: la plus grande valeur autorisée
return l'entier saisi.
"""
i = 0
ok = False
while not ok:
try:
s = input()
i = int(s)
if i < mini or i > maxi:
raise OverflowError("For number " + str(i))
ok = True
except EOFError as e:
print("Erreur de lecture : " + str(e), file=sys.stderr)
exit(1)
print("Erreur de format de nombre : " + str(e),
file=sys.stderr)
except OverflowError as e:
print("Erreur de bornes : " + str(e), file=sys.stderr)
return i

def read_float(mini=-sys.float_info.max, maxi=sys.float_info.max):

"""
Lit au clavier un flottant de type <tt>float</tt> compris entre
des bornes.
La lecture est répétée si le format n'est pas valide ou si les
bornes ne sont pas respectées.
param min: la plus petite valeur autorisée

param max: la plus grande valeur autorisée
return le flottant saisi.
"""
fl = 0.0
ok = False
while not ok:
try:
s = input()
fl = float(s)
if fl < mini or fl > maxi:
raise OverflowError("For number " + str(fl))
ok = True
except EOFError as e:
print("Erreur de lecture : " + str(e), file=sys.stderr)
exit(1)
print("Erreur de format de nombre : " + str(e),
file=sys.stderr)
except OverflowError as e:
print("Erreur de bornes : " + str(e), file=sys.stderr)
return fl
def stop():
"""
Affiche le message <tt>"Voulez-vous arrêter <O/N> ?</tt> et
renvoie <tt>true</tt> ou <tt>false</tt>
suivant que l'on désire arrêter ou non.
La lecture est répétée si le caractère introduit n'est pas valide.
return la valeur logique 'vrai' si on veut arrêter, 'faux' sinon.
"""
c = ' '
while c != 'O' and c != 'N':
c = input("Voulez-vous arrêter <O/N> ? ")
c = c.upper()
return c == 'O'

# in case of direct call of script ...

# just a test - demo
if __name__ == "__main__":
print('a = read_int()')
print('a ?', end=' ')
a = read_int()
print('a :', a)
print('a = read_int(0)')
a = read_int(0)
print('a :', a)
print('a = read_int(0, 10)')

a = read_int(0, 10)
print('a :', a)
print('a = read_int(maxi=5, mini=-5)')

a = read_int(maxi=5, mini=-5)
print('a :', a)
print('x = read_float()')
print('x ?', end=' ')
x = read_float()
print('x :', x)
print('x = read_float(1.0)')
x = read_float(1.0)
print('x :', x)
print('x = read_float(-1.5, 2.5)')

x = read_float(-1.5, 2.5)
print('x :', x)
print('x = read_float(maxi=1.5, mini=-0.5)')

x = read_float(maxi=1.5, mini=-0.5)
print('x :', x)
while not stop():

print('Vous continuer...')
print('Vous arrêter.')

14.2.2 Script de démonstration d’utilisation du package inout

Attention : Dans PyCharm, il faut ajouter le dossier syllabus\lib comme « Content Root » du projet demos qui
est dans le dossier syllabus (File -> Settings -> Project -> Project Structure). Ceci aura pour effet d’ajouter
syllabus\lib à la variable PYTHONPATH utilisée par l’interpréteur python. Il est important que les dossiers lib
et demos soient disjoints.
Le fichier inoutDemo.py du dossier syllabus\demos :
import sys
import inout
from inout import stop
print('a = inout.read_int()')
a = inout.read_int()
print('a :', a)
print('a = inout.read_int(0)')
a = inout.read_int(0)
print('a :', a)
print('a = inout.read_int(0, 10)')

a = inout.read_int(0, 10)
print('a :', a)
print('a = inout.read_int(maxi=5, mini=-5)')

a = inout.read_int(maxi=5, mini=-5)
print('a :', a)
print('x = inout.read_float()')
x = inout.read_float()
print('x :', x)
print('x = inout.read_float(1.0)')
x = inout.read_float(1.0)
print('x :', x)
print('x = inout.read_float(-1.5, 2.5)')

x = inout.read_float(-1.5, 2.5)
print('x :', x)
print('x = inout.read_float(maxi=1.5, mini=-0.5)')

x = inout.read_float(maxi=1.5, mini=-0.5)
print('x :', x)
while not stop(): # if only import inout : use inout.stop()

print('Vous continuer...')
print('Vous arrêter.')
Un affichage:
a = inout.read_int()
a ? 1
a : 1
a = inout.read_int(0)
a ? -1
Erreur de bornes : For number -1
2
a : 2
a = inout.read_int(0, 10)
a ? 11
Erreur de bornes : For number 11
9
a : 9
a = inout.read_int(maxi=5, mini=-5)
a ? 2
a : 2
x = inout.read_float()
x ? 1.1
x : 1.1
x = inout.read_float(1.0)
x ? 0.5
Erreur de bornes : For number 0.5
2.5
x : 2.5
x = inout.read_float(-1.5, 2.5)
x ? 1.5
x : 1.5
x = inout.read_float(maxi=1.5, mini=-0.5)
x ? -0.6
Erreur de bornes : For number -0.6
0.5
x : 0.5
Voulez-vous arrêter <O/N> ? f
Voulez-vous arrêter <O/N> ? n
Vous continuer...
Voulez-vous arrêter <O/N> ? o
Vous arrêter.

14.3 Exemple 3 : matrixSumDemo.py
Le script :

import inout
import sys
"""
Création, lecture, affichage et somme de matrices.
Attention, ceci est une approche procédurale. Il serait préférable de
créer
une classe Matrice. Nous verrons les concepts de la programmation orientée
objet plus tard.Effectue un tri par sélection sur un tableau d'entiers
entrés au clavier.
"""
def create_matrix():
print('Nombre de lignes ? ', end='')
nr = inout.read_int(1, 10)
print('Nombre de colonnes ? ', end='')
nc = inout.read_int(1, 10)
m = []
for i in range(nr):
r = []
for j in range(nc):
print("m[" + str(i) + "][" + str(j) + "] ? ", end='')
r.append(inout.read_float())
m.append(r)
print(m)
return m
def show_matrix(_m):
for i in range(len(_m)):
for j in range(len(_m[i])):
print("{0:<10.2f}".format(_m[i][j]), end='')
print()

def sum_matrix(_m1, _m2):

if len(_m1) != len(_m2):
raise ValueError("Incompatible dimensions for row number: " +
str(len(_m1)) + " != " + str(len(_m2)))
nr = len(_m1)
nc = len(_m1[0])
for i in range(nr):
if len(_m1[i]) != nc or len(_m2[i]) != nc:
raise ValueError(
"Incompatible dimensions for column number: " +
str(len(_m1[i])) + " != " + str(len(_m2[i])))
# ms = [[_m1[i][j] + _m2[i][j] for j in range(nc)] for i in range(nr)]
ms = []
for i in range(nr):
r = []
for j in range(nc):
r.append(_m1[i][j] + _m2[i][j])
ms.append(r)
return ms
is_stop = False
while not is_stop:
print("Matrice 1 ?")
mat1 = create_matrix()
print("Matrice 2 ?")
mat2 = create_matrix()
try:
mat3 = sum_matrix(mat1, mat2)
print('\nMatrice 1 :')
show_matrix(mat1)
print('\nMatrice 2 :')
show_matrix(mat2)
print('\nMatrice somme :')
show_matrix(mat3)
print("Erreur : " + str(e), file=sys.stderr)
is_stop = inout.stop()

Un affichage:
C:\Users\moulinjean\AppData\Local\Programs\Python\Python310\python.exe
D:/users/jean/Documents/Ann_2223/isib/python/2ZZ1303/syllabus/demos/matrix
SumDemo.py
Matrice 1 ?
Nombre de lignes ? 2
Nombre de colonnes ? 3
m[0][0] ? 1
m[0][1] ? 2
m[0][2] ? 3
m[1][0] ? 4
m[1][1] ? 5
m[1][2] ? 6
[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
Matrice 2 ?
m[0][0] ? 7
m[0][1] ? 8
m[0][2] ? 9
m[1][0] ? 4
m[1][1] ? 5
m[1][2] ? 6
[[7.0, 8.0, 9.0], [4.0, 5.0, 6.0]]
Matrice 1 :
1.00 2.00 3.00
4.00 5.00 6.00
Matrice 2 :
7.00 8.00 9.00
4.00 5.00 6.00
Matrice somme :
8.00 10.00 12.00
8.00 10.00 12.00
Voulez-vous arrêter <O/N> ? n
Matrice 1 ?
m[0][0] ? 1
m[0][1] ? 2
[[1.0, 2.0]]
Matrice 2 ?
m[0][0] ? 3
m[1][0] ? 4
[[3.0], [4.0]]
Erreur : Incompatible dimensions for row number: 1 != 2
Voulez-vous arrêter <O/N> ? o

14.4 Exemple 3 : pascalTriangleDemo.py
Le script :

"""
Affiche les 16 premières lignes du triangle de Pascal.
"""
NBR = 15
c = [[1]]
for n in range(1, NBR + 1):
r = [1]
r.extend([c[n - 1][i] + c[n - 1][i + 1] for i in range(0, n - 1)])
r.append(1)
# print(r)
c.append(r)
print(' n \\ m ', end='')

for m in range(0, NBR+1):
print("{0:<5d}".format(m), end='')
print()
for n, r in enumerate(c):
# print(i, _list[i])
print("{0:<2d} -> ".format(n), end='')
for e in r:
print("{0:<5d}".format(e), end='')
print()
print()
L’affichage:
n \ m 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 -> 1
1 -> 1 1
2 -> 1 2 1
3 -> 1 3 3 1
4 -> 1 4 6 4 1
5 -> 1 5 10 10 5 1
6 -> 1 6 15 20 15 6 1
7 -> 1 7 21 35 35 21 7 1
8 -> 1 8 28 56 70 56 28 8 1
9 -> 1 9 36 84 126 126 84 36 9 1
10 -> 1 10 45 120 210 252 210 120 45 10 1
11 -> 1 11 55 165 330 462 462 330 165 55 11 1
12 -> 1 12 66 220 495 792 924 792 495 220 66 12 1
13 -> 1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
14 -> 1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1
15 -> 1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1

15 TABLE DES MATIÈRES

1 Ressources et références ................................................................................................................................ 2
2 Présentation ................................................................................................................................................... 3
2.1 Qu’est Python ? ................................................................................................................................................. 3
3 Préliminaires.................................................................................................................................................. 4
4 Une première prise en main avec le shell interactif de python .................................................................... 5
5 Premiers scripts............................................................................................................................................ 11
5.1 prog1.py .............................................................................................................................................................. 11
5.2 prog2.py .............................................................................................................................................................. 12
6 Structure conditionelle ................................................................................................................................ 13
6.1 Structure conditionnelle if … ........................................................................................................................... 13
6.2 Script ifDemo.py ................................................................................................................................................ 13
7 Structures répétitives ................................................................................................................................... 15
7.1 Structure répétitive while … ............................................................................................................................ 15
7.1.1 Script whileDemo1.py..................................................................................................................................................... 15
7.1.2 Script whileDemo2.py..................................................................................................................................................... 16
7.1.3 Script noDoDemo.py....................................................................................................................................................... 17
7.2 Structure répétitive for … ................................................................................................................................ 18
7.2.1 Script forDemo.py ........................................................................................................................................................... 18
8 Les exceptions .............................................................................................................................................. 21
9 Les types de données non simples ............................................................................................................... 23
9.1 Chaîne de caractères ......................................................................................................................................... 23
9.1.1 Script strings.py .............................................................................................................................................................. 23
9.2 Tuples ................................................................................................................................................................. 25
9.2.1 Script tuples.py................................................................................................................................................................ 25
9.3 Listes ................................................................................................................................................................... 26
9.3.1 Script lists.py ................................................................................................................................................................... 26
9.3.2 Copies de listes, script listCopy.py ................................................................................................................................. 29
9.3.3 Listes en compréhension, script listComprehension.py .................................................................................................. 30
9.4 Ensembles ........................................................................................................................................................... 31
9.4.1 Script sets.py ................................................................................................................................................................... 31
9.5 Dictionnaires ...................................................................................................................................................... 32
9.5.1 Script dictionaries.py....................................................................................................................................................... 32
10 Les conversions de type ............................................................................................................................... 35
10.1 Script transtypage.py ........................................................................................................................................ 35
11 Les fonctions ................................................................................................................................................ 38
11.1 Script fibFctDemo.py ........................................................................................................................................ 38
11.2 Script gcd.py ...................................................................................................................................................... 39
11.3 Script badSwap.py............................................................................................................................................. 40
11.4 Script sumPolymorph.py .................................................................................................................................. 41
11.5 Script gatherScatterKwargs.py ........................................................................................................................ 42
11.6 Script rectIntegration.py .................................................................................................................................. 43
11.7 Script scope.py ................................................................................................................................................... 44

12 Les fichiers ................................................................................................................................................... 45

12.1 Script files.py ..................................................................................................................................................... 45
13 La programmation fonctionelle en Python................................................................................................. 49
13.1 Présentation ....................................................................................................................................................... 49
13.2 Itérateurs (iterators) .......................................................................................................................................... 50
13.3 Expressions génératrices (generator expressions) et listes en compréhension (list comprehensions) ......... 51
13.4 Générateurs (generators) .................................................................................................................................. 51
13.5 Small functions and the lambda expression .................................................................................................... 52
13.6 Fonctions intégrées (built-in functions) et itérateurs ...................................................................................... 52
13.7 Le module itertools ............................................................................................................................................ 57
13.8 Le module functools .......................................................................................................................................... 57
14 Exemples ...................................................................................................................................................... 58
14.1 Exemple 1 : selectionSortDemo.py................................................................................................................... 58
14.2 Exemple 2 : package inout ................................................................................................................................ 60
14.2.1 Package inout ............................................................................................................................................................. 60
14.2.2 Script de démonstration d’utilisation du package inout.............................................................................................. 63
14.3 Exemple 3 : matrixSumDemo.py ..................................................................................................................... 65
14.4 Exemple 3 : pascalTriangleDemo.py ............................................................................................................... 68
15 Table des matières ....................................................................................................................................... 69

2ZZ1303 Syl1 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2ZZ1303 Syl1 1

Transféré par

Droits d'auteur :

Formats disponibles

INSTITUT SUPERIEUR INDUSTRIEL DE BRUXELLES

Nom : Mattens Jean-Michel

Titre du syllabus : Introduction à la programmation Python 3

Acronyme de l’activité d’apprentissage : 2ZZ1303

Mattens Jean-Michel Edition 2022/2023

 Syllabus INFO-H-100 Informatique, Thierry Massart, ULB

 Think Python, Allen Downey, en téléchargement libre à partir du site

Introduction à la programmation Python

Introduction à la programmation Python

Introduction à la programmation Python

4 UNE PREMIÈRE PRISE EN MAIN AVEC LE SHELL

ActivePython 3.4.1.0 (ActiveState Software

>>> 'gains'+'bar' Les litéraux de chaînes de caractères

>>> x=1 La variable x ne doit pas être déclarée.

>>> x=1.2 x fait référence à un nouvel objet.

>>> x="hello" Les chaînes sont des séquences immuables

>>> x=(1,2,'trois') Les tuples sont des séquences immuables

>>> x=[1,2,'trois'] Les listes sont des séquences muables

Introduction à la programmation Python

>>> x[1] Le premier indice est 0.

>>> x={0,'un',2,"trois"} Les ensembles sont des types de données

Traceback (most recent call last):

>>> (x,y,z)=(1,2,3) Unpacking !

>>> x,y=y,x Ceci est une vraie permutation !

>>> t=1,2,3 Packing !

>>> a,b,c=t Unpacking.

>>> a=int(3.99) Convertion de float en int.

Return the tuple ((x-x%y)/y, x%y).

Introduction à la programmation Python

>>> eval('2*abs(-5)**2') Traite la chaîne somme une expression et

>>> float('3.1416') Conversion de string en float.

>>> x=input('x? ') Affiche l’invite et lit un string.

Introduction à la programmation Python

__author__ = "JM Mattens"

if len(sys.argv) != 3: # sys.argv is a list

L’affichage produit lorsqu’on transmet les arguments 1.1 et 2.2 au script :

1.1+ 2.2 = 3.3000000000000003

 """ permet d’introduire des commentaires multi lignes.

Introduction à la programmation Python

__author__ = "JM Mattens"

print("Addition de deux nombres flottants a et b")

Addition de deux nombres flottants a et b

 input() renvoie un string, il faut donc convertir en float.

Introduction à la programmation Python

"if" expression ":" suite

 expression est une expression booléenne

6.2 Script ifDemo.py

__author__ = "JM Mattens"

print("Résolution d'une équation du premier degré a X + b = 0")

Introduction à la programmation Python

Quelques affichages possibles :

Résolution d'une équation du premier degré a X + b = 0

Résolution d'une équation du premier degré a X + b = 0

Résolution d'une équation du premier degré a X + b = 0

 Python pratique le « court-circuitage » d’expressions logiques (« lazy evaluation »).

Introduction à la programmation Python

"while" expression ":" suite

 expression est une expression booléenne

7.1.1 Script whileDemo1.py

__author__ = "JM Mattens"

print("Vous devez deviner un nombre compris entre 0 et ", MAX, sep="")

Introduction à la programmation Python

Vous devez deviner un nombre compris entre 0 et 1000

author = "JM Mattens"

author = "JM Mattens"

author = "JM Mattens"

author = "JM Mattens"

author = "JM Mattens"

author = "JM Mattens"

author = "JM Mattens"