Les bases de la programmation

Python par l’exemple

Par Sundeep Agarwal - Laethy (traducteur) - Nothus (traducteur) - Petit Vince (traducteur)

Date de publication : 31 août 2018

Ce cours est un tutoriel qui se propose de vous apprendre le langage Python à travers des
exemples.

Commentez
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

I - Introduction..............................................................................................................................................................4
I-A - Installation...................................................................................................................................................... 4
I-B - Exemple Hello World..................................................................................................................................... 4
I-C - Exécution du programme Python.................................................................................................................. 5
I-D - Pour plus d’information.................................................................................................................................. 5
I-E - L’interpréteur Python...................................................................................................................................... 6
I-F - Lectures complémentaires............................................................................................................................. 6
I-G - Bibliothèque standard Python........................................................................................................................6
II - Types de données nombre et chaîne de caractères.............................................................................................6
II-A - Les types numériques...................................................................................................................................7
II-A-1 - Lectures complémentaires....................................................................................................................8
II-B - Les chaînes de caractères........................................................................................................................... 8
II-C - Les constantes............................................................................................................................................10
II-D - Les opérateurs intégrés.............................................................................................................................. 10
II-E - Lectures complémentaires.......................................................................................................................... 11
III - Les fonctions....................................................................................................................................................... 11
III-A - Définition d'une fonction.............................................................................................................................11
III-B - Valeur par défaut des arguments.............................................................................................................. 12
III-C - Lectures complémentaires......................................................................................................................... 12
III-D - Fonction print............................................................................................................................................. 13
III-E - Fonction range........................................................................................................................................... 16
III-F - Fonction déterminant le type......................................................................................................................16
III-G - Portée des variables..................................................................................................................................16
III-H - Lectures complémentaires......................................................................................................................... 18
IV - Obtenir une entrée utilisateur............................................................................................................................. 18
IV-A - Entrée d’entiers..........................................................................................................................................18
IV-B - Entrée de décimaux (nombres à virgule flottante).................................................................................... 18
IV-C - Entrée d’une chaîne de caractères........................................................................................................... 19
V - Exécution des commandes externes.................................................................................................................. 19
V-A - Appel de commandes Shell....................................................................................................................... 19
V-B - Appel de commandes Shell avec expansion............................................................................................. 20
V-C - Gérer les commandes de flux sortants et les redirections.........................................................................21
VI - Structures de contrôle........................................................................................................................................ 22
VI-A - Vérification de la condition........................................................................................................................ 22
VI-B - if................................................................................................................................................................. 23
VI-C - if-else comme opérateur de condition.......................................................................................................23
VI-D - for...............................................................................................................................................................24
VI-E - while........................................................................................................................................................... 24
VI-F - continue and break.................................................................................................................................... 24
VII - Les listes............................................................................................................................................................26
VII-A - Assignation des variables de liste............................................................................................................ 26
VII-B - Découpage et modification des listes.......................................................................................................26
VII-C - Copie des listes........................................................................................................................................ 28
VII-D - Méthodes de liste et divers...................................................................................................................... 29
VII-E - Lecture complémentaire........................................................................................................................... 33
VII-F - Les boucles...............................................................................................................................................33
VII-G - Compréhension d’une liste.......................................................................................................................34
VII-H - Lecture complémentaire........................................................................................................................... 35
VII-I - Obtention de la liste comme entrée utilisateur.......................................................................................... 35
VII-J - Obtention d’éléments aléatoires de la liste...............................................................................................35
VIII - Les types de données : séquence, ensemble et dictionnaire.......................................................................... 36
VIII-A - Chaînes....................................................................................................................................................36
VIII-B - Tuples.......................................................................................................................................................38
VIII-C - Ensemble................................................................................................................................................. 39
VIII-D - Dictionnaire.............................................................................................................................................. 40
VIII-E - Lecture supplémentaire........................................................................................................................... 42
IX - Manipulation du texte......................................................................................................................................... 42
IX-A - Méthodes de chaînes................................................................................................................................ 42

-2-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

X - Gestion des fichiers............................................................................................................................................. 45

X-A - Fonction Open............................................................................................................................................ 45
X-B - Lecture de fichiers...................................................................................................................................... 46
X-C - Écriture dans des fichiers...........................................................................................................................47
X-D - Édition « à la volée » avec fileinput........................................................................................................... 48
XI - Arguments de ligne de commande.................................................................................................................... 48
XII - Gestion des exceptions de débogage...............................................................................................................48
XIII - Docstrings......................................................................................................................................................... 48
XIV - Test................................................................................................................................................................... 49
XV - Exercices........................................................................................................................................................... 49
XVI - En complément................................................................................................................................................ 49

-3-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

I - Introduction

Selon Wikipédia, Python est un langage de programmation dynamique de haut niveau, polyvalent, interprété et
largement utilisé. Sa philosophie de conception met l'accent sur la lisibilité du code, et sa syntaxe permet aux
programmeurs d’écrire des programmes en moins de lignes de code que ce n’est possible dans des langages tels que
C ++ ou Java. Le langage fournit des concepts permettant d’écrire des programmes clairs à petite et grande échelle.

Le langage de programmation Python a été conçu par Guido van Rossum qui continue de superviser le processus
de développement du langage.

I-A - Installation

Pour installer Python, téléchargez la version de Python compatible à votre système d’exploitation sur le site officiel
de Python.

Python est par défaut installé sur la plupart des distributions Linux.

Vous pouvez consulter ce guide pour plus de détails pour la configuration d’un environnement virtuel et l’utilisation
de pip. Ne jamais utiliser la commande sudo pip à moins d’être certain de ce que vous faites.

Les exemples présentés ici portent sur les systèmes d’exploitation Unix, la version 3 de Python et utilisent le shell
bash.

Voici quelques outils que vous pouvez également utiliser pour exécuter le code Python en ligne :

• pythontutor : cet outil permet l'exécution du code dans les versions Python 2 et 3 et la visualisation du flot de
contrôle des instructions, et fournit des exemples de programmes.
• jupyter : Jupyter est une application web qui vous permet de créer et de partager des documents contenant
du code en ligne, des équations, des aperçus et du texte explicatif.
• ideone : cet outil est un outil de compilation et de débogage en ligne qui vous permet de compiler le code
source et de l'exécuter en ligne dans plus de soixante langages de programmation.
• Python Interpreter shell : permet également d’exécuter de code Python en ligne.

On suppose que vous êtes familier avec les lignes de commande. Sinon, consultez ce tutoriel de base sur
[Link].

I-B - Exemple Hello World

Commençons par un simple programme Python et apprenons à l’exécuter.

#!/usr/bin/python3

print("Hello World")

La première ligne comprend deux parties :

• /usr/bin/python3 est le chemin de l’interpréteur Python ;

• #! s’appelle Shebang et dit au chargeur de programmes d’utiliser le programme indiqué dans le chemin qui
suit.

La troisième ligne affiche le message Hello World avec un saut de ligne ajouté par défaut par la fonction print.

-4-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

I-C - Exécution du programme Python

Pour écrire votre programme, vous pouvez utiliser un éditeur de texte comme gedit, vim ou tout autre éditeur.

Après avoir enregistré le fichier, attribuez au fichier les droits d'exécution et exécutez le programme à partir d'un
terminal :

1. $ chmod +x hello_world.py
2. $ ./hello_world.py
3. Hello World

Pour trouver le répertoire d’installation et la version de Python dans votre système :

$ type python3
python3 is /usr/bin/python3

$ python3 --version
Python 3.4.3

Une erreur courante, pour ceux qui ont travaillé avec un livre ou un tutoriel sur la version 2 de Python ou qui ont
utilisé le langage Perl, est d'oublier les () avec la fonction print :

#!/usr/bin/python3

print "Have a nice day"

Selon le type d'erreur, il peut être facile de la repérer en fonction des messages d'erreur imprimés lors de l'exécution
du programme.

Dans cet exemple, nous obtenons le message Missing parentheses approprié.

$ ./syntax_error.py
File "./syntax_error.py", line 3
print "Have a nice day"
^
SyntaxError: Missing parentheses in call to 'print'

Les commentaires sur une seule ligne commencent par #.

#! a une signification spéciale seulement sur la première ligne du programme.

Nous aborderons les commentaires multilignes dans les chapitres suivants.

#!/usr/bin/python3

# Greeting message
print("Hello World")

I-D - Pour plus d’information

• Python docs - version 3

• Different ways of executing Python programs
• Where is Python used?
• Python docs - Errors and Exceptions

-5-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

I-E - L’interpréteur Python

• L’interpréteur Python est généralement utilisé pour exécuter des extraits de codes Python lorsqu’on apprend
le langage de programmation Python ou à des fins de débogage.
• Généralement, l’invite est : >>>.
• Dans les chapitres suivants de ce cours, certains sujets seront complétés par des exemples utilisant
l'interpréteur Python.
• La variable spéciale _ contient le résultat de la dernière expression imprimée.
• On peut saisir une partie de la commande et appuyer plusieurs fois sur la touche Flèche vers le Haut pour
faire correspondre les commandes de l'historique.
• La combinaison Ctrl + l permet d’effacer l'écran en conservant toutes les commandes saisies.
• Utilisez la commande exit() pour quitter.

1. $ python3
2. Python 3.4.3 (default, Oct 14 2015, 20:28:29)
3. [GCC 4.8.4] on linux
4. Type "help", "copyright", "credits" or "license" for more information.
5. >>> print("hi")
6. hi
7. >>> abc
8. Traceback (most recent call last):
9. File "<stdin>", line 1, in <module>
10. NameError: name 'abc' is not defined
11. >>> num = 5
12. >>> num
13. 5
14. >>> 3 + 4
15. 7
16. >>> 12 + _
17. 19
18. >>> exit()

I-F - Lectures complémentaires

• Python docs - Using the Python Interpreter

• Python docs - Interpreter example

I-G - Bibliothèque standard Python

Python docs - library

pypi - repository of software for the Python programming language

La bibliothèque contient des modules intégrés (écrits en C) qui fournissent un accès aux fonctionnalités du système
telles que les Entrées / Sorties de fichiers qui seraient autrement inaccessibles aux programmeurs Python, ainsi que
les modules écrits en Python qui fournissent des solutions standardisées pour de nombreux problèmes rencontrés
dans la programmation quotidienne.

Certains de ces modules sont explicitement conçus pour favoriser et améliorer la portabilité des programmes Python
en extrayant les spécificités de la plate-forme dans des API neutres.

II - Types de données nombre et chaîne de caractères

• Les nombres
• Les chaînes de caractères
• Les constantes
• Les opérateurs intégrés

-6-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

Le type d’une variable est déterminé automatiquement par Python. Il suffit d’attribuer une valeur à la variable avant
de l'utiliser ailleurs - comme une fonction d'affichage ou une partie de l'expression.

II-A - Les types numériques

• Exemples sur les entiers :

1. >>> num1 = 7
2. >>> num2 = 42
3. >>> total = num1 + num2
4. >>> print(total)
5. 49
6. >>> total
7. 49
8.
9. # Pas de limite à la précision des nombres entiers, uniquement limitée par la mémoire
disponible
10. >>> 34 ** 32
11. 10170102859315411774579628461341138023025901305856
12.
13. # L’utilisation d’une barre oblique simple / produit un résultat à virgule flottante
14. >>> 9 / 5
15. 1.8
16.
17. # L’utilisation de barres obliques doubles // ne donne que la partie entière du résultat sans
arrondi
18. >>> 9 // 5
19. 1
20.
21. >>> 9 % 5
22. 4

• Exemples sur les nombres à virgule flottante :

1. >>> appx_pi = 22 / 7
2. >>> appx_pi
3. 3.142857142857143
4.
5. >>> area = 42.16
6. >>> appx_pi + area
7. 45.30285714285714
8.
9. >>> num1
10. 7
11. >>> num1 + area
12. 49.16

• La notation scientifique peut être aussi utilisée :

1. >>> sci_num1 = 3.982e5

2. >>> sci_num2 = 9.32e-1
3. >>> sci_num1 + sci_num2
4. 398200.932
5.
6. >>> 2.13e21 + 5.23e22
7. 5.443e+22

• Les nombres binaires sont préfixés par 0b ou 0B (c'est-à-dire le chiffre 0 suivi de la lettre majuscule /
minuscule b) ;
• Les nombres en base 8(octal) sont préfixés par 0o ou 0O (c'est-à-dire le chiffre 0 suivi de la lettre majuscule /
minuscule o) ;
• De même, les nombres hexadécimaux sont précédés de 0x ou 0X :

1. >>> bin_num = 0b101

-7-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

2. >>> oct_num = 0o12

3. >>> hex_num = 0xF
4.
5. >>> bin_num
6. 5
7. >>> oct_num
8. 10
9. >>> hex_num
10. 15
11.
12. >>> oct_num + hex_num
13. 25

Le caractère _ peut être utilisé entre les chiffres pour plus de lisibilité. Cette notion a été introduite dans Python v3.6.

1. >>> 1_000_000
2. 1000000
3. >>> 1_00.3_352
4. 100.3352
5. >>> 0xff_ab1
6. 1047217
7.
8. # La mise en forme f-strings sera expliquée dans un chapitre ultérieur
9. >>> num = 34 ** 32
10. >>> print(f'{num:_}')
11. 10_170_102_859_315_411_774_579_628_461_341_138_023_025_901_305_856

II-A-1 - Lectures complémentaires

• Python docs - numbers

• decimal
• fractions
• complex
• Python docs - keywords : ne pas les utiliser comme variables

II-B - Les chaînes de caractères

• les chaînes de caractères peuvent être déclarées en utilisant des guillemets simples ou doubles.
• Lorsque la chaîne elle-même contient des guillemets doubles et simples, utilisez \ pour échapper les
guillemets qui font partie de la chaîne.

1. >>> str1 = 'This is a string'

2. >>> str1
3. 'This is a string'
4. >>> greeting = "Hello World!"
5. >>> greeting
6. 'Hello World!'
7.
8. >>> weather = "It's a nice and warm day"
9. >>> weather
10. "It's a nice and warm day"
11. >>> print(weather)
12. It's a nice and warm day
13.
14. >>> weather = 'It\'s a nice and warm day'
15. >>> print(weather)
16. It's a nice and warm day

Les séquences d'échappement comme le caractère de retour à la ligne \n peuvent être utilisées dans la déclaration
d’une chaîne de caractères.

1. >>> colors = 'Blue\nRed\nGreen'

2. >>> colors

-8-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

3. 'Blue\nRed\nGreen'
4.
5. >>> print(colors)
6. Blue
7. Red
8. Green

Utilisez le préfixe r (r pour raw (brut)) si vous ne voulez pas que les séquences d'échappement soient interprétées.
Ce préfixe est couramment utilisé avec des expressions régulières, lire Correspondance de modèle et extraction
pour avoir des exemples.

1. >>> raw_str = r'Blue\nRed\nGreen'

2. >>> print(raw_str)
3. Blue\nRed\nGreen
4.
5. # Pour voir comment les chaînes de caractères sont stockées en interne
6. >>> raw_str
7. 'Blue\\nRed\\nGreen'

• Concaténation des chaînes de caractères et répétitions :

1. >>> str1 = 'Hello'

2. >>> str2 = ' World'
3. >>> print(str1 + str2)
4. Hello World
5.
6. >>> style_char = '-'
7. >>> style_char * 10
8. '----------'
9.
10. >>> word = 'buffalo '
11. >>> print(word * 8)
12. buffalo buffalo buffalo buffalo buffalo buffalo buffalo buffalo
13.
14. # Python v3.6 permet l'interpolation des variables avec les f-strings
15. >>> msg = f'{str1} there'
16. >>> msg
17. 'Hello there'

• Chaînes de caractères entre triples guillemets. Comme les chaînes de caractères simples, """ ou ''' peuvent
être utilisés ainsi que les caractères d'échappement en utilisant \,

1. #!/usr/bin/python3
2.
3. """
4. Cette ligne fait partie d’un commentaire multiligne
5. Ce programme montre des exemples de chaînes de caractères entre triples guillemets
6. """
7.
8. # attribuer plusieurs chaînes de caractères à la variable
9. poem = """\
10. The woods are lovely, dark and deep,
11. But I have promises to keep,
12. And miles to go before I sleep,
13. And miles to go before I sleep.
14. """
15.
16. print(poem, end='')

Les chaînes de caractères entre triples guillemets sont également utiles pour la documentation du code. Voir le
chapitre Doctrings pour des exemples.

1. $ ./triple_quoted_string.py
2. The woods are lovely, dark and deep,
3. But I have promises to keep,
4. And miles to go before I sleep,

-9-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

5. And miles to go before I sleep.

6. $

• Python docs - strings

• Python docs - f-strings - pour plus d'exemples et de mises en garde

• Python docs - List of Escape Sequences and more info on strings

• Python docs - Binary Sequence Types

II-C - Les constantes

• Paraphrasé à partir de docs Python – constantes

• None est la seule valeur du type NoneType
• None est souvent utilisé pour représenter l'absence de valeur
• False : la valeur fausse du type booléen
• True : la valeur vraie du type booléen
• Python docs - Truth Value Testing

1. >>> bool(2)
2. True
3. >>> bool(0)
4. False
5. >>> bool('')
6. False
7. >>> bool('a')
8. True

II-D - Les opérateurs intégrés

• Opérateurs arithmétiques

• + addition
• - soustraction
• * multiplication
• / division (résultat à virgule flottante )
• // division (division entière, le résultat n'est pas arrondi)
• ** exponentiation
• % modulo (reste de la division entière).
• Les opérateurs de chaîne de caractères

• + concaténation de chaîne de caractères

• * répétition de chaîne de caractères
• Les opérateurs de comparaison

• == égal à
• > plus grand que
• < plus petit que
• != différent
• >= supérieur ou égal à
• <= inférieur ou égal à
• logique booléenne

• and et logique
• or ou logique

- 10 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• not non logique

• opérateurs bit à bit

• & et
• | ou
• ^ ou exclusif
• ~ bits inversés
• >> décalage à droite
• << décalage à gauche

Et plus encore…

II-E - Lectures complémentaires

• Python docs - Numeric types – Liste complète des opérations et des priorités.
• Python docs - String methods

III - Les fonctions

III-A - Définition d'une fonction

1. #!/usr/bin/python3
2.
3. # ----- Fonction sans argument -----
4. def greeting():
5. print("-----------------------------")
6. print(" Hello World ")
7. print("-----------------------------")
8.
9. greeting()
10.
11. # ----- Fonction avec arguments -----
12. def somme_deux_nombres(num1, num2):
13. total = num1 + num2
14. print("{} + {} = {}".format(num1, num2, total))
15.
16. somme_deux_nombres(3, 4)
17.
18. # ----- Fonction avec une valeur de retour -----
19. def carre(num):
20. return num * num
21.
22. my_num = 3
23. print(carre(2))
24. print(carre(my_num))

• Le mot-clef def est utilisé pour définir un corps de fonction.

• Les fonctions doivent être définies avant tout usage.

• Une erreur de syntaxe courante, est l’oubli de : à la fin de l'instruction de définition d'une fonction.
• Les blocs (corps) des fonctions, structures de contrôle, etc., sont distingués grâce à l'indentation :

• l'indentation recommandée est de 4 espaces consécutifs ;

• bonnes pratiques de style - documentation Python docs.
• Par défaut, la valeur de retour de return (comme son absence) est None.
• Comment les variables sont-elles passées aux fonctions en Python.
• format est traité dans le sujet suivant.

1. $ ./[Link]

- 11 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

2. -----------------------------
3. Hello World
4. -----------------------------
5. 3 + 4 = 7
6. 4
7. 9

III-B - Valeur par défaut des arguments

1. #!/usr/bin/python3
2.
3. # ----- Fonction avec un argument avec une valeur par défaut -----
4. def greeting(style_char='-'):
5. print(style_char * 29)
6. print("Hello World")
7. print(style_char * 29)
8.
9. print("Style par défaut")
10. greeting()
11.
12. print("\ncarctère de style *")
13. greeting('*')
14.
15. print("\ncaractère de style =")
16. greeting(style_char='=')

Les fonctions peuvent fréquemment avoir un comportement par défaut, modifié par le passage d’un argument
pertinent si nécessaire.

1. $ ./functions_default_arg_value.py
2. Style par défaut
3. -----------------------------
4. Hello World
5. -----------------------------
6.
7. Si le style passé est "*"
8. *****************************
9. Hello World
10. *****************************
11.
12. Si le style passé est "="
13. =============================
14. Hello World
15. =============================

• Les triples guillemets de commentaires permettent de décrire l'usage de la fonction et sont généralement
repris par l'outil de génération de documentation.
• Pour éviter d'alourdir les exemples de ce tutoriel, les docstrings des programmes et de la définition des
fonctions ne sont pas repris
voir le chapitre sur les docstrings pour les exemples et discussions à ce propos.

1. def num_square(num):
2. """
3. returns square of number
4. """
5.
6. return num * num

III-C - Lectures complémentaires

Il y a de nombreuses manières d’appeler une fonction et d’autres types de déclarations ; merci de vous référer aux
liens fournis pour davantage d’informations :

- 12 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• définir une fonction – documentation Python ;

• fonctions natives de Python – documentation Python.

III-D - Fonction print

• Par défaut, la fonction print ajoute systématiquement une ligne à la fin de son retour.
• Ce comportement peut être modifié en passant votre propre chaîne de caractères à l’argument end de cette
fonction.

1. >>> print("hi")
2. hi
3. >>> print("hi", end='')
4. hi>>>
5. >>> print("hi", end=' !!\n')
6. hi !!
7. >>>

• La fonction help peut être utilisée pour obtenir la documentation par l’interpréteur.
• Appuyer sur q pour revenir à l’aide.

1. >>> help(print)
2.
3. Help on built-in function print in module builtins:
4.
5. print(...)
6. print(value, ..., sep=' ', end='\n', file=[Link], flush=False)
7.
8. Prints the values to a stream, or to [Link] by default.
9. Optional keyword arguments:
10. file: a file-like object (stream); defaults to the current [Link].
11. sep: string inserted between values, default a space.
12. end: string appended after the last value, default a newline.
13. flush: whether to forcibly flush the stream.

• Plusieurs arguments peuvent être passés à la fonction print grâce au séparateur d’arguments , lors de son
appel.
• La valeur par défaut de l’argument sep, est un espace simple.

1. >>> a = 5
2. >>> b = 2
3.
4. >>> print(a+b, a-b)
5. 7 3
6.
7. >>> print(a+b, a-b, sep=' : ')
8. 7 : 3
9.
10. >>> print(a+b, a-b, sep='\n')
11. 7
12. 3

• Lors de l’affichage de variables, la méthode str est appelée et permet de donner une représentation en
chaîne de caractère (représentation humaine).
• Ainsi, une conversion explicite n’est pas nécessaire, à moins qu’une concaténation soit requise.

1. >>> greeting = 'Hello World'

2. >>> print(greeting)
3. Hello World
4. >>> num = 42
5. >>> print(num)
6. 42
7.
8. >>> print(greeting + '. We are learning Python')
9. Hello World. We are learning Python

- 13 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

10. >>> print(greeting, '. We are learning Python', sep='')

11. Hello World. We are learning Python
12.
13. >>> print("She bought " + num + " apples")
14. Traceback (most recent call last):
15. File "<stdin>", line 1, in <module>
16. TypeError: Can't convert 'int' object to str implicitly
17.
18. >>> print("She bought " + str(num) + " apples")
19. She bought 42 apples

Comme autre solution, vous pouvez modifier sep avec plusieurs arguments :

1. >>> print("She bought", num, "apples")

2. She bought 42 apples
3.
4. >>> items = 15
5. >>> print("No. of items:", items)
6. No. of items: 15
7.
8. >>> print("No. of items:", items, sep='')
9. No. of items:15

• Pour rediriger le flux d’affichage à stderr au lieu du flux par défaut stdout, il vous suffit de modifier l’argument
file.
• Voir aussi [Link]().

1. >>> import sys

2. >>> print("Error!! Not a valid input", file=[Link])
3. Error!! Not a valid input

• La fonction [Link]() peut être utilisée pour mettre en forme les chaînes de caractères et permettre
l’utilisation de plusieurs variables, d’une façon plus élégante que la seule concaténation.

1. >>> num1 = 42
2. >>> num2 = 7
3.
4. >>> '{} + {} = {}'.format(num1, num2, num1 + num2)
5. '42 + 7 = 49'
6.
7. # or save formatting in a variable and use wherever needed
8. >>> op_fmt = '{} + {} = {}'
9. >>> op_fmt.format(num1, num2, num1 + num2)
10. '42 + 7 = 49'
11. >>> op_fmt.format(num1, 29, num1 + 29)
12. '42 + 29 = 71'
13.
14. # and of course the expression can be used inside print directly
15. >>> print('{} + {} = {}'.format(num1, num2, num1 + num2))
16. 42 + 7 = 49

• Utilisation d’arguments de type numérique.

1. >>> num1
2. 42
3. >>> num2
4. 7
5. >>> print("{0} + {1} * {0} = {2}".format(num1, num2, num1 + num2 * num1))
6. 42 + 7 * 42 = 336

• Formatage de nombres – spécification utilisée avec argument optionnel et nombre optionnel, suivi par `:` puis
le style de formatage.

1. >>> appx_pi = 22 / 7
2. >>> appx_pi

- 14 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

3. 3.142857142857143
4.
5. # restricting number of digits after decimal point
6. # value is rounded off
7. >>> print("{0:.2f}".format(appx_pi))
8. 3.14
9. >>> print("{0:.3f}".format(appx_pi))
10. 3.143
11.
12. # aligning
13. >>> print("{0:<10.3f} and 5.12".format(appx_pi))
14. 3.143 and 5.12
15. >>> print("{0:>10.3f} and 5.12".format(appx_pi))
16. 3.143 and 5.12
17.
18. # zero filling
19. >>> print("{0:08.3f}".format(appx_pi))
20. 0003.143

• Changement de base.

1. >>> print("42 in binary = {:b}".format(42))

2. 42 in binary = 101010
3. >>> print("42 in octal = {:o}".format(42))
4. 42 in octal = 52
5. >>> print("241 in hex = {:x}".format(241))
6. 241 in hex = f1
7.
8. # add # for 0b/0o/0x prefix
9. >>> print("42 in binary = {:#b}".format(42))
10. 42 in binary = 0b101010
11.
12. >>> hex_str = "{:x}".format(42)
13. >>> hex_str
14. '2a'
15.
16. # can also use format built-in function
17. >>> format(42, 'x')
18. '2a'
19. >>> format(42, '#x')
20. '0x2a'
21.
22. # converting string to int
23. >>> int(hex_str, base=16)
24. 42
25. >>> int('0x2a', base=16)
26. 42

• Similaire au préfixe d’affichage brut r, l’utilisation du préfixe f permet la représentation de nombres.

Introduit depuis Python v3.6.
• Similaire à [Link](), la variable ou l’expression est spécifiée par {}.

1. >>> num1 = 42
2. >>> num2 = 7
3. >>> f'{num1} + {num2} = {num1 + num2}'
4. '42 + 7 = 49'
5. >>> print(f'{num1} + {num2} = {num1 + num2}')
6. 42 + 7 = 49
7.
8. >>> appx_pi = 22 / 7
9. >>> f'{appx_pi:08.3f}'
10. '0003.143'
11.
12. >>> f'{20:x}'
13. '14'
14. >>> f'{20:#x}'
15. '0x14'

Lectures complémentaires :

- 15 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• formatage de chaînes de caractères – documentation Python – pour davantage d’informations ou

d’exemples ;
• f-string – documentation Python – pour davantage d’exemples et de mises en garde.

III-E - Fonction range

Par défaut, les arguments sont les suivants : start=0 et step=1 – vous pouvez donc les utiliser ou ne pas en tenir en
compte et passer vos propres arguments :

• range(stop) ;
• range(start, stop) ;
• range(start, stop, step) ;
• veuillez noter que le retour de la fonction range n’inclut pas la valeur définie à stop – ce sera toujours l’entier
précédent la valeur de stop ;
• voir le chapitre sur les listes pour l’introduction et les explications de cette partie ;
• ranges – documentation Python – pour davantage d’informations et d’exemples.

1. >>> range(5)
2. range(0, 5)
3.
4. >>> list(range(5))
5. [0, 1, 2, 3, 4]
6.
7. >>> list(range(-2, 2))
8. [-2, -1, 0, 1]
9.
10. >>> list(range(1, 15, 2))
11. [1, 3, 5, 7, 9, 11, 13]
12.
13. >>> list(range(10, -5, -2))
14. [10, 8, 6, 4, 2, 0, -2, -4]

III-F - Fonction déterminant le type

Cette fonction est utile pour connaître le type de données ou de la variable qui est lui passée en argument.

1. >>> type(5)
2. <class 'int'>
3.
4. >>> type('Hi there!')
5. <class 'str'>
6.
7. >>> type(range(7))
8. <class 'range'>
9.
10. >>> type(None)
11. <class 'NoneType'>
12.
13. >>> type(True)
14. <class 'bool'>
15.
16. >>> arr = list(range(4))
17. >>> arr
18. [0, 1, 2, 3]
19. >>> type(arr)
20. <class 'list'>

III-G - Portée des variables

1. #!/usr/bin/python3
2.
3. def print_num():

- 16 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

4. print("Yeehaw! num is visible in this scope, its value is: " + str(num))
5.
6. num = 25
7. print_num()

• Les variables définies avant l’appel à la fonction sont également visibles dans la définition de la fonction.
• Valeur des arguments par défaut – documentation Python – voir la description pour connaître quand les
valeurs par défaut sont évaluées (interprétées).

1. $ ./variable_scope_1.py
2. Yeehaw! num is visible in this scope, its value is: 25

Que se passe-t-il lorsqu’une variable déclarée dans un bloc est utilisée en dehors de ce dernier ?

1. #!/usr/bin/python3
2.
3. def square_of_num(num):
4. sqr_num = num * num
5.
6. square_of_num(5)
7. print("5 * 5 = {}".format(sqr_num))

• Ici sqr_num est déclaré au sein de la fonction square_of_num et n’est pas accessible en dehors.

1. $ ./variable_scope_2.py
2. Traceback (most recent call last):
3. File "./variable_scope_2.py", line 7, in <module>
4. print("5 * 5 = {}".format(sqr_num))
5. NameError: name 'sqr_num' is not defined

Une des solutions pour contourner un tel comportement est l’utilisation du mot-clef global.

1. #!/usr/bin/python3
2.
3. def square_of_num(num):
4. global sqr_num
5. sqr_num = num * num
6.
7. square_of_num(5)
8. print("5 * 5 = {}".format(sqr_num))

• Désormais, vous pouvez accéder à la variable sqr_num en dehors de la définition de la fonction.

1. $ ./variable_scope_3.py
2. 5 * 5 = 25

Si le nom d’une variable est identique à l’intérieur et à l’extérieur d’une fonction (conflit de nom), le changement de
valeur dans un bloc de fonction n’affecte pas la variable extérieure à ce bloc.

1. #!/usr/bin/python3
2.
3. sqr_num = 4
4.
5. def square_of_num(num):
6. sqr_num = num * num
7. print("5 * 5 = {}".format(sqr_num))
8.
9. square_of_num(5)
10. print("Whoops! sqr_num is still {}!".format(sqr_num))

Notez que l’utilisation de global sqr_num affectera ici sqr_num, la variable en dehors du bloc définissant la fonction.

1. $ ./variable_scope_4.py

- 17 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

2. 5 * 5 = 25
3. Whoops! sqr_num is still 4!

III-H - Lectures complémentaires

Exemple de portée – documentation Python.

la déclaration globale – documentation Python.

IV - Obtenir une entrée utilisateur

IV-A - Entrée d’entiers

1. #!/usr/bin/python3
2.
3. usr_ip = input("Enter an integer number: ")
4.
5. # Nécessité de convertir l’entrée dans le type désiré
6. usr_num = int(usr_ip)
7. sqr_num = usr_num * usr_num
8.
9. print("Square of entered number is: {}".format(sqr_num))

• Testons désormais avec des entiers et une chaîne de caractères.

• Entiers littéraux – documentation Python.

1. $ ./user_input_int.py
2. Enter an integer number: 23
3. Square of entered number is: 529
4.
5. $ ./user_input_int.py
6. Enter an integer number: abc
7. Traceback (most recent call last):
8. File "./user_input_int.py", line 6, in <module>
9. usr_num = int(usr_ip)
10. ValueError: invalid literal for int() with base 10: 'abc'

IV-B - Entrée de décimaux (nombres à virgule flottante)

1. #!/usr/bin/python3
2.
3. usr_ip = input("Enter a floating point number: ")
4.
5. # Need to explicitly convert input string to desired type
6. usr_num = float(usr_ip)
7. sqr_num = usr_num * usr_num
8.
9. # Limit the number of digits after decimal points to 2
10. print("Square of entered number is: {0:.2f}".format(sqr_num))

• La notation scientifique E peut parfois être utilisée lorsqu’elle est requise.

• Entrée de décimaux littéraux – documentation Python.
• Entrée de décimaux (nombre à virgule flottante) – documentation Python.

1. $ ./user_input_float.py
2. Enter a floating point number: 3.232
3. Square of entered number is: 10.45
4.
5. $ ./user_input_float.py
6. Enter a floating point number: 42.7e5
7. Square of entered number is: 18232900000000.00

- 18 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

8.
9. $ ./user_input_float.py
10. Enter a floating point number: abc
11. Traceback (most recent call last):
12. File "./user_input_float.py", line 6, in <module>
13. usr_num = float(usr_ip)
14. ValueError: could not convert string to float: 'abc'

IV-C - Entrée d’une chaîne de caractères

1. #!/usr/bin/python3
2.
3. usr_name = input("Hi there! What's your name? ")
4. usr_color = input("And your favorite color is? ")
5.
6. print("{}, I like the {} color too".format(usr_name, usr_color))

• Ici vous n’avez pas de conversion à effectuer, ni aucun caractère de nouvelle ligne à prendre en compte
contrairement à Perl.

1. $ ./user_input_str.py
2. Hi there! What's your name? learnbyexample
3. And your favorite color is? blue
4. learnbyexample, I like the blue color too

V - Exécution des commandes externes

Note de traduction : dans ce contexte, certains termes n’ont pas été francisés (Shell, wildcards, etc.).

Certaines parties affichées peuvent être différentes en fonction de votre environnement de travail, de votre nom
d’utilisateur, votre répertoire de travail, etc.

V-A - Appel de commandes Shell

1. #!/usr/bin/python3
2.
3. import subprocess
4.
5. # Exécuter la commande externe 'date'
6. [Link]('date')
7.
8. # Passer des options et des arguments à la commande
9. print("\nToday is ", end="", flush=True)
10. [Link](['date', '-u', '+%A'])
11.
12. # Autre exemple
13. print("\nSearching for 'hello world'", flush=True)
14. [Link](['grep', '-i', 'hello world', 'hello_world.py'])

• L’instruction import est utilisée pour charger le module subprocess qui fait partie de la bibliothèque Python
standard).
• La fonction call du module subprocess est une des solutions pour appeler une commande externe.
• En passant la valeur True à l’argument flush (False par défaut), vous vous assurez que votre message sera
affiché avant [Link].
• Pour transmettre des arguments à la commande, une liste de chaînes de caractères est passée au lieu d'une
chaîne de caractère unique.

1. $ ./calling_shell_commands.py
2. Tue Jun 21 18:35:33 IST 2016
3.
4. Today is Tuesday

- 19 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

5.
6. Searching for 'hello world'
7. print("Hello World")

Lecture complémentaire :

• documentation Python – module subprocess ;

• documentation Python – [Link] ;
• différence [Link] et [Link] ;
• documentation Python – module import.

V-B - Appel de commandes Shell avec expansion

#!/usr/bin/python3

import subprocess

# Exécution sans expansion

print("Pas expansion shell quand shell=False", flush=True)
[Link](['echo', 'Hello $USER'])

# Exécution avec l’expansion Shell

print("\nexpansionshell quand shell=True", flush=True)
[Link]('echo Hello $USER', shell=True)

# Echappement de la chaîne si nécessaire

print("\nSearching for 'hello world'", flush=True)
[Link]('grep -i \'hello world\' hello_world.py', shell=True)

• Par défaut [Link] n’est pas étendu (jolers du Shell), lors de l’exécution d'une substitution de
commande, etc.
• Vous pouvez outrepasser ce comportement en passant la valeur True à l’argument shell.
• Notez que la commande entière est maintenant passée en tant que chaîne et non en tant que liste de
chaînes.
• Les apostrophes (quotes : ')doivent être échappées (\').
• Utilisez shell=True seulement si vous êtes sûr que la commande doit être exécutée dans l’environnement
Shell, sinon il pourrait y avoir une faille de sécurité.
• documentation Python – subprocess, Popen.

1. $ ./shell_expansion.py
2. Pas d' expansion shell quand shell=False
3. Hello $USER
4.
5. expansion shell quand shell=True
6. Hello learnbyexample
7.
8. Recherche pour 'hello world'
9. print("Hello World")

• Dans certains cas, vous pouvez éviter l’échappement en alternant l’utilisation de guillemets et d’apostrophes
comme suit :

# utilisation alternée d'apostrophes et de guillemets

[Link]('grep -i "hello world" hello_world.py', shell=True)

# ou ceci
[Link]("grep -i 'hello world' hello_world.py", shell=True)

• La redirection des sorties de commandes Shell peut être utilisée comme d’ordinaire.

# pour plus de clarté, utilisez des variables et évitez les longues chaînes dans des fonctions
cmd = "grep -h 'test' [Link] test_list.txt > grep_test.txt"

- 20 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

[Link](cmd, shell=True)

Solution de remplacement de l’utilisation de Shell=True.

>>> import subprocess, os

>>> [Link](['echo', 'Hello', [Link]("USER")])
Hello learnbyexample
0

• [Link]("USER") permet de récupérer la variable d’environnement USER.

• 0 est la valeur de retour / de sortie, indiquant la bonne réalisation de la commande. C'est une notification de
l'interpréteur python qui affiche également la valeur de retour.

V-C - Gérer les commandes de flux sortants et les redirections

#!/usr/bin/python3

import subprocess

# La sortie inclut les messages d’erreur

print("Obtenir la sortie de la commande 'pwd' ", flush=True)
curr_working_dir = [Link]('pwd')
print(curr_working_dir)

# Obtenir le statut et les retours de la commande exécutée

# Toute autre valeur que `0` est considérée comme une commande ayant rencontré une erreur
ls_command = 'ls hello_world.py [Link]'
print("\nAppel de la commande '{}'".format(ls_command), flush=True)
(ls_status, ls_output) = [Link](ls_command)
print("status: {}\nsortie : '{}'".format(ls_status, ls_output))

# Vous pouvez supprimer les messages d’erreurs si vous le souhaitez

# [Link]() renvoie le statut de la commande et qui peut être utilisé
print("\nCalling command with error msg suppressed", flush=True)
ls_status = [Link](ls_command, shell=True, stderr=[Link])
print("status: {}".format(ls_status))

• La sortie de getstatusoutput() est un de type de données tuple – plus d’informations et d’exemples dans les
prochains chapitres.
• getstatusoutput() et getoutput() sont des fonctions héritées.
• D’autres fonctions plus récentes et plus d'options de sécurité :

• documentation Python subprocess.check_output ;

• documentation Python [Link].

$ ./shell_command_output_redirections.py
Obtention de la sortie de la commande 'pwd'
/home/learnbyexample/Python/python_programs

Appel de la commande 'ls hello_world.py [Link]'

status: 2
sortie : 'ls: cannot access [Link]: No such file or directory
hello_world.py'

Appel de la commande avec messages d'erreur supprimés

hello_world.py
status: 2

- 21 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

VI - Structures de contrôle

VI-A - Vérification de la condition

• Vérification simple et combinaison des tests.

>>> num = 5
>>> num > 2
True
>>> num > 3 and num <= 5
True
>>> 3 < num <= 5
True
>>> num % 3 == 0 or num % 5 == 0
True

>>> fav_fiction = 'Harry Potter'

>>> fav_detective = 'Sherlock Holmes'
>>> fav_fiction == fav_detective
False
>>> fav_fiction == "Harry Potter"
True

• Test de la variable ou de la valeur par elle-même.

>>> bool(num)
True
>>> bool(fav_detective)
True
>>> bool(3)
True
>>> bool(0)
False
>>> bool("")
False
>>> bool(None)
False

>>> if -1:
... print("-1 évalue à True dans la vérification de condition")
...

-1 évalue à True dans la vérification de condition

• Utilisation de l’opérateur « in » dans la vérification de condition.

Comparez cette méthode de vérification

>>> def num_chk(n):

... if n == 10 or n == 21 or n == 33:
... print("Le nombre passe la condition")
... else:
... print("Le nombre ne passe pas la condition")
...
>>> num_chk(10)
Le nombre passe la condition
>>> num_chk(12)
Le nombre ne passe pas la condition

avec celle-ci

>>> def num_chk(n):

... if n in (10, 21, 33):

- 22 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

... print("Le nombre passe la condition")

... else:
... print("Le nombre ne passe pas la condition")
...
>>> num_chk(12)
Le nombre ne passe pas la condition
>>> num_chk(10)
Le nombre passe la condition

• (10, 21, 33) est un type de données tuple. Il sera traité dans les chapitres suivants.
• Python docs - Truth Value Testing

VI-B - if

1. #!/usr/bin/python3
2.
3. num = 45
4.
5. # only if
6. if num > 25:
7. print("Hourra! {} est plus grand que 25".format(num))
8.
9. # if-else
10. if num % 2 == 0:
11. print("{} est un nombre pair".format(num))
12. else:
13. print("{} est un nombre impair".format(num))
14.
15. # if-elif-else
16. # N’importe quel chiffre de elif peut être utilisé
17. if num < 0:
18. print("{} est un nombre négatif".format(num))
19. elif num > 0:
20. print("{} est un nombre positif".format(num))
21. else:
22. print("{} n’est ni positif ni négatif".format(num))

• Le bloc de code pour les fonctions, le contrôle des structures, etc. est distingué par un code de retrait
(indentation) :

• une encoche à 4 espaces est recommandée ;

• consultez Python docs - Coding Style pour plus de détails.
• Une erreur de syntaxe commune est d’omettre « : » à la fin des instructions de la structure de contrôle.
• L’utilisation de « () » autour des conditions est optionnelle.
• L’indentation peut avoir un nombre quelconque d’instructions, y compris des lignes vides.

$ ./if_elif_else.py
Hourra! 45 est plus grand que 25
45 est un nombre impair
45 est un nombre positif

VI-C - if-else comme opérateur de condition

1. #!/usr/bin/python3
2.
3. num = 42
4.
5. num_type = 'even' if num % 2 == 0 else 'odd'
6. print("{} is an {} number".format(num, num_type))

• Contrairement à beaucoup d’autres langages, Python n’a pas d’opérateur conditionnel « ?: ».

• L’utilisation de« if-else »dans une seule ligne comme dans cet exemple est une solution de contournement.

- 23 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

1. $ ./if_else_oneliner.py
2. 42 est un nombre pair

VI-D - for

1. #!/usr/bin/python3
2.
3. number = 9
4. for i in range(1, 5):
5. mul_table = number * i
6. print("{} * {} = {}".format(number, i, mul_table))

• Une boucle basée sur une itération traditionnelle peut être écrite en utilisant la fonction« range ».

• Rappelez-vous que par défaut« start=0 », « step=1 » et que la valeur« stop »n’est pas incluse.
• Les itérations sur des variables comme list, tuples, etc. seront traitées dans les chapitres suivants.
• La documentation officielle est ici : Python docs – itertools .

1. $ ./for_loop.py
2. 9 * 1 = 9
3. 9 * 2 = 18
4. 9 * 3 = 27
5. 9 * 4 = 36

VI-E - while

1. #!/usr/bin/python3
2.
3. # toujours demander à l’utilisateur d’insérer un nombre jusqu’à avoir un nombre positif
4. usr_string = 'Ce n’est pas un nombre'
5. while not usr_string.isnumeric():
6. usr_string = input("Entrez un entier positif : ")

• La boucle while nous permet d’exécuter un bloc d’instructions jusqu’à satisfaction d’une condition.
• Python docs - string methods .

1. $ ./while_loop.py
2. Entrez un entier positif : abc
3. Entrez un entier positif : 1.2
4. Entrez un entier positif : 23
5. $

VI-F - continue and break

Les mots-clefs « continue » et « break » sont utilisés pour modifier le flux normal des boucles dans certaines
conditions.

continue – ignore le reste des instructions de la boucle et commence la prochaine itération.

1. #!/usr/bin/python3
2.
3. prev_num = 0
4. curr_num = 0
5. print("Les dix premiers nombres de la suite de Fibonacci: ", end='')
6.
7.
8. for num in range(10):
9. print(curr_num, end=' ')
10.
11. if num == 0:
12. curr_num = 1

- 24 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

13. continue
14.
15. temp = curr_num
16. curr_num = curr_num + prev_num
17. prev_num = temp
18.
19. print("")

• La fonction « continue » peut être placée n’importe où dans la boucle sans avoir à se soucier de la
complication du flux de code.
• Cet exemple est juste pour vous montrer l’utilisation de la fonction « continue », veuillez voir ici pour d’autres
méthodes Python.

1. $ ./loop_with_continue.py
2. Les dix premiers nombres de la suite de Fibonacci: 0 1 1 2 3 5 8 13 21 34

break – ignore le reste des instructions dans la boucle (s’il y en a) et quitte la boucle.

1. #!/usr/bin/python3
2.
3. import random
4.
5. while True:
6. # comme avec la fonction range(), 500 n’est pas inclus
7. random_int = [Link](500)
8. if random_int % 4 == 0 and random_int % 6 == 0:
9. break
10. print("Nombre aléatoire divisible par 4 et 6: {}".format(random_int))

• while True est généralement utilisée comme une boucle infinie.

• randrange a les mêmes arguments de start, stop, step que la fonction range .
• Python docs – random .

1. $ ./loop_with_break.py
2. Nombre aléatoire divisible par 4 et 6: 168
3. $ ./loop_with_break.py
4. Nombre aléatoire divisible par 4 et 6: 216
5. $ ./loop_with_break.py

Nombre aléatoire divisible par 4 et 6: 24

L’exemple while_loop.py peut être réécrit en utilisant la fonction « break ».

1. >>> while True:

2. usr_string = input("Entrez un entier positif : ")
3. if usr_string.isnumeric():
4. break
5.
6. Entrez un entier positif : a
7. Entrez un entier positif : 3.14
8. Entrez un entier positif : 1
9. >>>

• Dans le cas de boucles imbriquées, les fonctions « continue » et « break » n’affectent que la boucle parente
immédiate.
• Python docs - else clauses on loops .

- 25 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

VII - Les listes

VII-A - Assignation des variables de liste

• Listes simples et récupération d’éléments de liste.

1. >>> vowels = ['a', 'e', 'i', 'o', 'u']

2. >>> vowels
3. ['a', 'e', 'i', 'o', 'u']
4. >>> vowels[0]
5. 'a'
6. >>> vowels[2]
7. 'i'
8. >>> vowels[10]
9. Traceback (most recent call last):
10. File "<stdin>", line 1, in <module>
11. IndexError: list index out of range
12.
13. >>> even_numbers = list(range(2, 11, 2))
14. >>> even_numbers
15. [2, 4, 6, 8, 10]
16. >>> even_numbers[-1]
17. 10
18. >>> even_numbers[-2]
19. 8
20. >>> even_numbers[-15]
21. Traceback (most recent call last):
22. File "<stdin>", line 1, in <module>
23. IndexError: list index out of range

• Mélange des types de données et listes multidimensionnelles.

1. >>> student = ['learnbyexample', 2016, 'Linux, Vim, Python']

2. >>> print(student)
3. ['learnbyexample', 2016, 'Linux, Vim, Python']
4.
5. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
6. >>> list_2D[0][0]
7. 1
8. >>> list_2D[1][0]
9. 1.2

• Python docs – lists .

VII-B - Découpage et modification des listes

• Comme la fonction « range() », l’index de la liste a le format « start:stop:step » , la valeur « stop » étant non
inclusive.

1. >>> books = ['Harry Potter', 'Sherlock Holmes', 'To Kill a Mocking Bird']
2. >>> books[2] = "Ender's Game"
3. >>> print(books)
4. ['Harry Potter', 'Sherlock Holmes', "Ender's Game"]
5.
6. >>> prime = [2, 3, 5, 7, 11]
7. >>> prime[2:4]
8. [5, 7]
9. >>> prime[:3]
10. [2, 3, 5]
11. >>> prime[3:]
12. [7, 11]
13.
14. >>> prime[-1]
15. 11

- 26 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

16. >>> prime[-1:]

17. [11]
18. >>> prime[-2:]
19. [7, 11]
20.
21.
22. >>> prime[::1]
23. [2, 3, 5, 7, 11]
24. >>> prime[::2]
25. [2, 5, 11]
26. >>> prime[3:1:-1]
27. [7, 5]
28. >>> prime[::-1]
29. [11, 7, 5, 3, 2]
30. >>> prime[:]
31. [2, 3, 5, 7, 11]

• Quand les valeurs « start » et « stop« sont les mêmes.

• Utiles quand elles sont générées par programmation, regardez l’exercice sur le traitement de texte comme
exemple.

1. >>> nums = [1.2, -0.2, 0, 2]

2. >>> nums[0:0]
3. []
4. >>> nums[2:2]
5. []
6. >>> nums[-1:-1]
7. []
8. >>> nums[21:21]
9. []

• Le format d’indexation peut être utilisé pour extraire une variable de la liste ou se modifier.

1. >>> nums = [1.2, -0.2, 0, 2]

2. >>> nums[:2] = [1]
3. >>> nums
4. [1, 0, 2]
5.
6. >>> nums = [1.2, -0.2, 0, 2, 4, 23]
7. >>> nums[:5:2] = [1, 4, 3]
8. >>> nums
9. [1, -0.2, 4, 2, 3, 23]
10.
11. >>> nums = [1, 2, 3, 23]
12. >>> nums[::-1] = [1, 4, 5, 2]
13. >>> nums
14. [2, 5, 4, 1]

• Ceci aide à modifier une liste sans changer son id, ce qui est utile si le nom de variable est référencé autre
part (regardez la section suivante)

1. >>> id(nums)
2. 140598790579336
3. >>> nums[:] = [1, 2, 5, 4.3]
4. >>> nums
5. [1, 2, 5, 4.3]
6. >>> id(nums)
7. 140598790579336
8.
9. # l’affectation sans utiliser [:] changera son id
10. >>> nums = [1.2, -0.2, 0, 2]
11. >>> id(nums)
12. 140598782943752

- 27 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

VII-C - Copie des listes

• Les variables dans Python contiennent une référence aux objets.

• Par exemple, quand une variable d’entier est modifiée, la référence de la variable est mise à jour avec un
nouvel objet.
• La fonction « id() » retourne l’ « identité » d’un objet.
• La distinction entre les variables se référant à des types immuables comme integer et strings, ne cause
généralement pas une confusion lors de leur usage.

1. >>> a = 5
2. >>> id(a)
3. 10105952
4. >>> a = 10
5. >>> id(a)
6. 10106112
7.
8. >>> b = a
9. >>> id(b)
10. 10106112
11. >>> b = 4
12. >>> b
13. 4
14. >>> a
15. 10
16. >>> id(b)
17. 10105920

• Cependant, il est important de savoir, pour les variables de types muables comme « lists », comment ces
variables sont copiées et transmises aux fonctions.
• Quand un élément d’une liste de variables est modifié, Python le fait en changeant la valeur (mutation) d’un
objet à cet index.

1. >>> a = [1, 2, 5, 4.3]

2. >>> a
3. [1, 2, 5, 4.3]
4. >>> b = a
5. >>> b
6. [1, 2, 5, 4.3]
7. >>> id(a)
8. 140684757120264
9. >>> id(b)
10. 140684757120264
11. >>> b[0] = 'xyz'
12. >>> b
13. ['xyz', 2, 5, 4.3]
14. >>> a
15. ['xyz', 2, 5, 4.3]

• Évitez de copier des listes utilisant un format d’indexation, car ceci fonctionne pour des listes d’une seule
dimension et non pour des dimensions supérieures.

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> b = prime[:]
3. >>> id(prime)
4. 140684818101064
5. >>> id(b)
6. 140684818886024
7. >>> b[0] = 'a'
8. >>> b
9. ['a', 3, 5, 7, 11]
10. >>> prime
11. [2, 3, 5, 7, 11]
12.
13. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
14. >>> a = list_2D[:]

- 28 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

15. >>> id(list_2D)

16. 140684818102344
17. >>> id(a)
18. 140684818103048
19. >>> a
20. [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
21. >>> a[0][0] = 'a'
22. >>> a
23. [['a', 3, 2, 10], [1.2, -0.2, 0, 2]]
24. >>> list_2D
25. [['a', 3, 2, 10], [1.2, -0.2, 0, 2]]

• Utilisez à la place le module « copy ».

1. >>> import copy

2. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
3. >>> c = [Link](list_2D)
4. >>> c[0][0] = 'a'
5. >>> c
6. [['a', 3, 2, 10], [1.2, -0.2, 0, 2]]
7. >>> list_2D
8. [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]

VII-D - Méthodes de liste et divers

• Ajout d’éléments à une liste.

1. >>> books = []
2. >>> books
3. []
4. >>> [Link]('Harry Potter')
5. >>> books
6. ['Harry Potter']
7.
8. >>> even_numbers = [2, 4, 6, 8, 10]
9. >>> even_numbers += [12, 14, 16, 18, 20]
10. >>> even_numbers
11. [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
12.
13. >>> even_numbers = [2, 4, 6, 8, 10]
14. >>> even_numbers.extend([12, 14, 16, 18, 20])
15. >>> even_numbers
16. [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
17.
18. >>> a = [[1, 3], [2, 4]]
19. >>> [Link]([[5, 6]])
20. >>> a
21. [[1, 3], [2, 4], [5, 6]]

• Suppression d’éléments d’une liste en fonction d’un index.

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> [Link]()
3. 11
4. >>> prime
5. [2, 3, 5, 7]
6. >>> [Link](0)
7. 2
8. >>> prime
9. [3, 5, 7]
10.
11. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
12. >>> list_2D[0].pop(0)
13. 1
14. >>> list_2D
15. [[3, 2, 10], [1.2, -0.2, 0, 2]]
16.

- 29 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

17. >>> list_2D.pop(1)

18. [1.2, -0.2, 0, 2]
19. >>> list_2D
20. [[3, 2, 10]]

• Utilisation de « del » pour supprimer des éléments.

1. >>> nums = [1.2, -0.2, 0, 2, 4, 23]

2. >>> del nums[1]
3. >>> nums
4. [1.2, 0, 2, 4, 23]
5. # vous pouvez utiliser aussi bien la notation de découpage
6. >>> del nums[1:4]
7. >>> nums
8. [1.2, 23]
9.
10. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]
11. >>> del list_2D[0][1]
12. >>> list_2D
13. [[1, 2, 10], [1.2, -0.2, 0, 2]]
14.
15. >>> del list_2D[0]
16. >>> list_2D
17. [[1.2, -0.2, 0, 2]]

• Effacement d’une liste.

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> [Link]()
3. >>> prime
4. []

• Suppression d’éléments d’une liste en fonction de la valeur.

1. >>> even_numbers = [2, 4, 6, 8, 10]

2. >>> even_numbers.remove(8)
3. >>> even_numbers
4. [2, 4, 6, 10]
5. >>> even_numbers.remove(12)
6. Traceback (most recent call last):
7. File "<stdin>", line 1, in <module>
8. ValueError: [Link](x): x not in list

• Insertion d’éléments à une position d’index particulière.

1. >>> books = ['Harry Potter', 'Sherlock Holmes', 'To Kill a Mocking Bird']
2. >>> [Link](2, "The Martian")
3. >>> books
4. ['Harry Potter', 'Sherlock Holmes', 'The Martian', 'To Kill a Mocking Bird']

• Obtention d’un index d’un élément.

1. >>> even_numbers = [2, 4, 6, 8, 10]

2. >>> even_numbers.index(6)
3. 2
4. >>> even_numbers.index(12)
5. Traceback (most recent call last):
6. File "<stdin>", line 1, in <module>
7. ValueError: 12 is not in list

• Vérification de présence d’un élément.

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> 3 in prime
3. True

- 30 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

4. >>> 13 in prime
5. False

• Tri .

1. >>> a = [1, 5.3, 321, 0, 1, 2]

2. >>> [Link]()
3. >>> a
4. [0, 1, 1, 2, 5.3, 321]
5.
6. >>> a = [1, 5.3, 321, 0, 1, 2]
7. >>> [Link](reverse=True)
8. >>> a
9. [321, 5.3, 2, 1, 1, 0]

Triez en vous basant sur une clef , par exemple en vous basant sur la longueur d’une chaîne.
L es expressions lambda sont utiles pour transmettre une seule expression personnalisée, par exemple un tri
basé sur la deuxième lettre.

1. >>> words = ['fuliginous', 'crusado', 'morello', 'irk', 'seam']

2. >>> [Link](key=len)
3. >>> words
4. ['irk', 'seam', 'crusado', 'morello', 'fuliginous']
5.
6. >>> [Link](key=lambda x: x[1])
7. >>> words
8. ['seam', 'morello', 'irk', 'crusado', 'fuliginous']

Si la liste originale ne doit pas changer, utilisez une fonction triée .

1. >>> nums = [-1, 34, 0.2, -4, 309]

2. >>> nums_desc = sorted(nums, reverse=True)
3. >>> nums_desc
4. [309, 34, 0.2, -1, -4]
5.
6. >>> sorted(nums, key=abs)
7. [0.2, -1, -4, 34, 309]

• min et max.

1. >>> a = [321, 899.232, 5.3, 2, 1, -1]

2. >>> min(a)
3. -1
4. >>> max(a)
5. 899.232

• Nombre de fois qu’un élément est présent.

1. >>> nums = [15, 99, 19, 382, 43, 19]

2. >>> [Link](99)
3. 1
4. >>> [Link](19)
5. 2
6. >>> [Link](23)
7. 0

• Liste inversée

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> id(prime)
3. 140684818102088
4. >>> [Link]()
5. >>> prime
6. [11, 7, 5, 3, 2]

- 31 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

7. >>> id(prime)
8. 140684818102088
9.
10. >>> a = [1, 5.3, 321, 0, 1, 2]
11. >>> id(a)
12. 140684818886024
13. >>> a = a[::-1]
14. >>> a
15. [2, 1, 0, 321, 5.3, 1]
16. >>> id(a)
17. 140684818102664

• Fonction len permettant d’obtenir la taille d’une liste.

1. >>> prime = [2, 3, 5, 7, 11]

2. >>> len(prime)
3. 5
4.
5. >>> s = len(prime) // 2
6. >>> s
7. 2
8. >>> prime[:s]
9. [2, 3]
10. >>> prime[s:]
11. [5, 7, 11]
12. >>>

• Somme des listes numériques.

1. >>> a = [321, 5.3, 2, 1, 1, 0]

2. >>> sum(a)
3. 330.3

• Fonctions all et any .

1. >>> conditions = [True, False, True]

2. >>> all(conditions)
3. False
4. >>> any(conditions)
5. True
6.
7. >>> conditions[1] = True
8. >>> all(conditions)
9. True
10.
11. >>> a = [321, 5.3, 2, 1, 1, 0]
12. >>> all(a)
13. False
14. >>> any(a)
15. True

• Comparaison des listes.

1. >>> prime
2. [2, 3, 5, 7, 11]
3. >>> a = [4, 2]
4. >>> prime == a
5. False
6.
7. >>> prime == [2, 3, 5, 11, 7]
8. False
9. >>> prime == [2, 3, 5, 7, 11]
10. True

- 32 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

VII-E - Lecture complémentaire

• Python docs - more on lists.

• Python docs – collections .

VII-F - Les boucles

1. #!/usr/bin/python3
2.
3. numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
4. odd_numbers = []
5. even_numbers = []
6.
7. for num in numbers:
8. odd_numbers.append(num) if(num % 2) else even_numbers.append(num)
9.
10. print("nombres : {}".format(numbers))
11. print("nombres_impairs : {}".format(odd_numbers))
12. print("nombres_pairs : {}".format(even_numbers))

• Généralement, il suffit de traiter chaque élément d’une liste sans avoir besoin des valeurs d’index de ces
éléments.

1. $ ./list_looping.py
2. numbers: [2, 12, 3, 25, 624, 21, 5, 9, 12]
3. odd_numbers: [3, 25, 21, 5, 9]
4. even_numbers: [2, 12, 624, 12]

• Utilisez « enumerate() » si vous avez besoin d’un index et d’un élément.

1. #!/usr/bin/python3
2.
3. north_dishes = ['Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha']
4.
5. print("Mes vaisselles favorites du nord de l’Inde :")
6. for idx, item in enumerate(north_dishes):
7. print("{}. {}".format(idx + 1, item))

• Dans ce cas, on obtient un « tuple » à chaque itération consistant en un compte (valeur par défaut 0) et un
élément de la liste.
• Python docs – enumerate .

1. $ ./list_looping_enumeration.py
2. Mes vaisselles favorites du nord de l’Inde :
3. 1. Aloo tikki
4. 2. Baati
5. 3. Khichdi
6. 4. Makki roti
7. 5. Poha

• Une valeur de départ peut aussi être spécifiée.

1. >>> north_dishes = ['Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha']

2. >>> for idx, item in enumerate(north_dishes, start=1):
3. ... print(idx, item, sep='. ')
4. ...
5. 1. Aloo tikki
6. 2. Baati
7. 3. Khichdi
8. 4. Makki roti
9. 5. Poha

- 33 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• Utilisez « zip() » pour parcourir deux listes ou plus simultanément.

• Python docs - zip

1. >>> odd = [1, 3, 5]

2. >>> even = [2, 4, 6]
3. >>> for i, j in zip(odd, even):
4. ... print(i + j)
5. ...
6. 3
7. 7
8. 11

VII-G - Compréhension d’une liste

1. #!/usr/bin/python3
2.
3. import time
4.
5. numbers = list(range(1,100001))
6. fl_square_numbers = []
7.
8. # référencer time
9. t0 = time.perf_counter()
10.
11. # ------------ la boucle for ------------
12. for num in numbers:
13. fl_square_numbers.append(num * num)
14.
15. # référencer time
16. t1 = time.perf_counter()
17.
18. # ------- compréhension de la liste -------
19. lc_square_numbers = [num * num for num in numbers]
20.
21. # performance des résultats
22. t2 = time.perf_counter()
23. fl_time = t1 - t0
24. lc_time = t2 - t1
25. improvement = (fl_time - lc_time) / fl_time * 100
26.
27. print("Temps avec la boucle for : {:.4f}".format(fl_time))
28. print("Temps avec la liste de compréhension : {:.4f}".format(lc_time))
29. print("Amélioration : {:.2f}%".format(improvement))
30.
31. if fl_square_numbers == lc_square_numbers:
32. print("\nfl_square_numbers et lc_square_numbers sont équivalents")
33. else:
34. print("\nfl_square_numbers et lc_square_numbers ne sont PAS équivalents")

• La liste de compréhension est une façon de construire certaines boucles usuelles dans le langage python
• C’est une option plus lisible et plus rapide que les boucles.
• Dans cet exemple, ne pas avoir l’obligation d’utiliser la méthode « append() » permet aussi de gagner
beaucoup de temps dans le cas de compréhension de liste.
• Les valeurs de temps dans cet exemple sont indicatives et ne devraient pas être considérées comme
absolues
Elles varient même entre deux exécutions, que dire de machines différentes.

1. $ ./list_comprehension.py
2. Temps avec la boucle for : 0.0142
3. Temps avec liste de compréhension : 0.0062
4. Amélioration : 56.36%
5.
6. fl_square_numbers et lc_square_numbers sont équivalents

• Compréhension de la liste conditionnelle.

- 34 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

1. # utilisation de la condition if-else dans la compréhension de liste

2. numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
3. odd_numbers = []
4. even_numbers = []
5. [odd_numbers.append(num) if(num % 2) else even_numbers.append(num) for num in numbers]
6.
7. # ou d’une façon plus simple et lisible
8. numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]
9. odd_numbers = [num for num in numbers if num % 2]
10. even_numbers = [num for num in numbers if not num % 2]

• Exemple d’utilisation de la fonction zip.

1. >>> p = [1, 3, 5]
2. >>> q = [3, 214, 53]
3. >>> [i+j for i,j in zip(p, q)]
4. [4, 217, 58]
5. >>> [i*j for i,j in zip(p, q)]
6. [3, 642, 265]

Utilisez un générateur d’expression , la séquence doit être transmise à une autre fonction

1. >>> sum(i*j for i,j in zip(p, q))

2. 910

VII-H - Lecture complémentaire

Pour plus d’exemples, y compris les boucles imbriquées, veuillez voir ici :

• Python docs - list comprehensions ;

• Python docs – perf_counter ;
• Python docs – timeit.

VII-I - Obtention de la liste comme entrée utilisateur

1. >>> b = input('Entrez des mots séparés par des espaces : ').split()

2. Entrez des mots séparés par des espaces : foo bar baz
3. >>> b
4. ['foo', 'bar', 'baz']
5.
6. >>> nums = [int(n) for n in input('Entrez des nombres séparés par des espaces : ').split()]
7. Entrez des numéros séparés par des espaces : 1 23 5
8. >>> nums
9. [1, 23, 5]
10.
11. >>> ip_str = input('Entrez des nombres premiers séparés par des virgules : ')
12. Entrez des nombres premiers séparés par des virgules : 3,5,7
13. >>> primes = [int(n) for n in ip_str.split(',')]
14. >>> primes
15. [3, 5, 7]

• Étant donné que les entrées de l’utilisateur sont toutes traitées comme des chaînes, il est nécessaire de
traiter en fonction du délimiteur convenu et du type de données requis.

VII-J - Obtention d’éléments aléatoires de la liste

• Obtenir un élément aléatoirement.

1. >>> import random

2. >>> a = [4, 5, 2, 76]
3. >>> [Link](a)

- 35 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

4. 76
5. >>> [Link](a)
6. 4

• Réarranger aléatoirement des éléments d’une liste.

1. >>> [Link](a)
2. >>> a
3. [5, 2, 76, 4]

• Obtenir aléatoirement une partie d’une liste, ce qui ne modifie pas la variable de liste.

1. >>> [Link](a, k=3)

2. [76, 2, 5]
3.
4. >>> [Link](range(1000), k=5)
5. [68, 203, 15, 757, 580]

• Obtenir des éléments aléatoires d’une liste sans répétition en créant une fonction itérable en utilisant Python
docs – iter.
• La différence par rapport à la simple utilisation d’une liste aléatoire est que cela évite le besoin de maintenir
un compteur d’index séparé et qu’une exception automatique est déclenchée si elle sort de la plage.

1. >>> nums = [1, 3, 6, -12, 1.2, 3.14]

2. >>> [Link](nums)
3. >>> nums_iter = iter(nums)
4. >>> print(next(nums_iter))
5. 3.14
6. >>> print(next(nums_iter))
7. 1.2
8. >>> for n in nums_iter:
9. ... print(n)
10. ...
11. 1
12. 3
13. -12
14. 6
15. >>> print(next(nums_iter))
16. Traceback (most recent call last):
17. File "<stdin>", line 1, in <module>
18. StopIteration

• Python docs - random pour plus d’informations.

• Nouveau dans la version 3.6 - [Link].

• Python docs – next.

VIII - Les types de données : séquence, ensemble et dictionnaire

Nous avons déjà vu des types de séquences dans les chapitres précédents - chaînes, intervalles et listes. Le tuple
est un autre type de séquence.
Nous verrons plus d'opérations sur les chaînes suivies par tuple, les ensembles et les dictionnaires dans ce chapitre.

VIII-A - Chaînes

• L’indexation que nous avons vue pour les listes peut aussi bien être appliquée pour les chaînes.

• Comme les chaînes sont non réinscriptibles, elles ne peuvent pas être modifiées comme des listes.

1. >>> book = "Alchemist"

- 36 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

2. >>> book[0]
3. 'A'
4. >>> book[3]
5. 'h'
6. >>> book[-1]
7. 't'
8. >>> book[10]
9. Traceback (dernier appel passé):
10. File "<stdin>", line 1, in <module>
11. IndexError: string index out of range
12.
13. >>> book[2:6]
14. 'chem'
15. >>> book[:5]
16. 'Alche'
17. >>> book[5:]
18. 'mist'
19. >>> book[::-1]
20. 'tsimehclA'
21. >>> book[:]
22. 'Alchemist'
23.
24. >>> list(book)
25. ['A', 'l', 'c', 'h', 'e', 'm', 'i', 's', 't']
26.
27. >>> import string
28. >>> string.ascii_lowercase[:10]
29. 'abcdefghij'
30. >>> list([Link])
31. ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

• Boucles sur chaînes.

1. >>> book
2. 'Alchemist'
3.
4. >>> for char in book:
5. ... print(char)
6. ...
7. A
8. l
9. c
10. h
11. e
12. m
13. i
14. s
15. t

• Autres opérations.

1. >>> book
2. 'Alchemist'
3.
4. >>> len(book)
5. 9
6.
7. >>> [Link]('A')
8. 0
9. >>> [Link]('t')
10. 8
11.
12. >>> 'A' in book
13. True
14. >>> 'B' in book
15. False
16. >>> 'z' not in book
17. True
18.
19. >>> min('zealous')

- 37 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

20. 'a'
21. >>> max('zealous')
22. 'z'

VIII-B - Tuples

• Les tuples sont similaires aux listes, mais ils sont non réinscriptibles et aussi utiles d’autres façons.
• Les éléments individuels sont à la fois mutables et immuables.

1. >>> north_dishes = ('Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha')

2. >>> north_dishes
3. ('Aloo tikki', 'Baati', 'Khichdi', 'Makki roti', 'Poha')
4.
5. >>> north_dishes[0]
6. 'Aloo tikki'
7. >>> north_dishes[-1]
8. 'Poha'
9. >>> north_dishes[6]
10. Traceback (Dernier appel passé):
11. File "<stdin>", line 1, in <module>
12. IndexError: Indice tuple hors limites
13.
14. >>> north_dishes[::-1]
15. ('Poha', 'Makki roti', 'Khichdi', 'Baati', 'Aloo tikki')
16.
17. >>> north_dishes[0] = 'Poori'
18. Traceback (Dernier appel passé):
19. File "<stdin>", line 1, in <module>
20. TypeError: L’objet tuple ne prend pas en charge l’attribution d’élément

• Exemple d’opérations.

1. >>> 'roti' in north_dishes

2. False
3. >>> 'Makki roti' in north_dishes
4. True
5.
6. >>> len(north_dishes)
7. 5
8.
9. >>> min(north_dishes)
10. 'Aloo tikki'
11. >>> max(north_dishes)
12. 'Poha'
13.
14. >>> for dish in north_dishes:
15. ... print(dish)
16. ...
17. Aloo tikki
18. Baati
19. Khichdi
20. Makki roti
21. Poha

• Un tuple est pratique pour l’affectation de plusieurs variables et le renvoi de plus d’une valeur dans des fonctions.

• Nous avons déjà vu un exemple expliquant quand utiliser « enumerate » pour parcourir des listes.

1. >>> a = 5
2. >>> b = 20
3. >>> a, b = b, a
4. >>> a
5. 20
6. >>> b
7. 5
8.

- 38 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

9. >>> c = 'foo'
10. >>> a, b, c = c, a, b
11. >>> a
12. 'foo'
13. >>> b
14. 20
15. >>> c
16. 5
17.
18. >>> def min_max(arr):
19. ... return min(arr), max(arr)
20. ...
21. >>> min_max([23, 53, 1, -34, 9])
22. (-34, 53)

• L’utilisation de () n’est pas toujours nécessaire.

1. >>> words = 'day', 'night'

2. >>> words
3. ('day', 'night')
4.
5. >>> coordinates = ((1,2), (4,3), (92,3))
6. >>> coordinates
7. ((1, 2), (4, 3), (92, 3))
8.
9. >>> prime = [2, 3, 5, 7, 11]
10. >>> prime_tuple = tuple((idx + 1, num) for idx, num in enumerate(prime))
11. >>> prime_tuple
12. ((1, 2), (2, 3), (3, 5), (4, 7), (5, 11))

• Convertir d’autres types en tuples.

• Similaire à list().

1. >>> tuple('books')
2. ('b', 'o', 'o', 'k', 's')
3.
4. >>> a = [321, 899.232, 5.3, 2, 1, -1]
5. >>> tuple(a)
6. (321, 899.232, 5.3, 2, 1, -1)

• Les types de données peuvent être mélangés et utilisés en différentes façons.

1. >>> a = [(1,2), ['a', 'b'], ('good', 'bad')]

2. >>> a
3. [(1, 2), ['a', 'b'], ('good', 'bad')]
4.
5. >>> b = ((1,2), ['a', 'b'], ('good', 'bad'))
6. >>> b
7. ((1, 2), ['a', 'b'], ('good', 'bad'))

• Python docs – tuple .

• Python docs - tuple tutorial .

VIII-C - Ensemble

• L’ensemble est une collection non ordonnée d’objets.

• Il possède un type de données mutable.
• Il est typiquement utilisé pour maintenir une séquence unique, effectuer des opérations d’ensemble comme
l’intersection, l’union, la différence, la différence symétrique, etc.

1. >>> nums = {3, 2, 5, 7, 1, 6.3}

2. >>> nums

- 39 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

3. {1, 2, 3, 5, 6.3, 7}
4.
5. >>> primes = {3, 2, 11, 3, 5, 13, 2}
6. >>> primes
7. {2, 3, 11, 13, 5}
8.
9. >>> [Link](primes)
10. {1, 2, 3, 5, 6.3, 7, 11, 13}
11.
12. >>> [Link](nums)
13. {11, 13}
14. >>> [Link](primes)
15. {1, 6.3, 7}

• Exemples d’opérations.

1. >>> len(nums)
2. 6
3.
4. >>> nums[0]
5. Traceback (Dernier appel passé):
6. File "<stdin>", line 1, in <module>
7. TypeError: 'set' object does not support indexing
8.
9. >>> book
10. 'Alchemist'
11. >>> set(book)
12. {'i', 'l', 's', 'A', 'e', 'h', 'm', 't', 'c'}
13. >>> set([1, 5, 3, 1, 9])
14. {1, 9, 3, 5}
15. >>> list(set([1, 5, 3, 1, 9]))
16. [1, 9, 3, 5]
17.
18. >>> nums = {1, 2, 3, 5, 6.3, 7}
19. >>> nums
20. {1, 2, 3, 5, 6.3, 7}
21. >>> [Link]()
22. 1
23. >>> nums
24. {2, 3, 5, 6.3, 7}
25.
26. >>> [Link](1)
27. >>> nums
28. {1, 2, 3, 5, 6.3, 7}
29.
30. >>> 6.3 in nums
31. True
32.
33. >>> for n in nums:
34. ... print(n)
35. ...
36. 1
37. 2
38. 3
39. 5
40. 6.3
41. 7

• Python docs – set .

• Python docs – frozenset .
• set tutorial .

VIII-D - Dictionnaire

• Les types « dict » peuvent être considérés comme une liste non ordonnée du key:value ou une liste nommée
d’éléments.

- 40 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• Jusqu’à Python v3.5 (et quelques implémentations de la version 3.6), il était inutile de conserver l’ordre
d’insertion des éléments « dict ».

1. >>> marks = {'Rahul' : 86, 'Ravi' : 92, 'Rohit' : 75}

2. >>> marks
3. {'Ravi': 92, 'Rohit': 75, 'Rahul': 86}
4.
5. >>> fav_books = {}
6. >>> fav_books['Fantaisie'] = 'Harry Potter'
7. >>> fav_books['Détective'] = 'Sherlock Holmes'
8. >>> fav_books['Thriller'] = 'The Da Vinci Code'
9. >>> fav_books
10. {'Thriller': 'The Da Vinci Code', 'Fantaisie': 'Harry Potter', 'Détective': 'Sherlock
Holmes'}
11.
12. >>> [Link]()
13. dict_keys(['Ravi', 'Rohit', 'Rahul'])
14.
15. >>> fav_books.values()
16. dict_values(['The Da Vinci Code', 'Harry Potter', 'Sherlock Holmes'])

• Boucle et impression.

1. >>> for book in fav_books.values():

2. ... print(book)
3. ...
4. The Da Vinci Code
5. Harry Potter
6. Sherlock Holmes
7.
8. >>> for name, mark in [Link]():
9. ... print(name, mark, sep=' : ')
10. ...
11. Ravi: 92
12. Rohit: 75
13. Rahul: 86
14.
15. >>> import pprint
16. >>> pp = [Link](indent=4)
17. >>> [Link](fav_books)
18. { 'Détective' : 'Sherlock Holmes',
19. 'Fantaisie' : 'Harry Potter',
20. 'Thriller' : 'The Da Vinci Code'}

• Modification des dictionnaires et exemple d’opérations.

1. >>> marks
2. {'Ravi': 92, 'Rohit': 75, 'Rahul': 86}
3. >>> marks['Rajan'] = 79
4. >>> marks
5. {'Ravi': 92, 'Rohit': 75, 'Rahul': 86, 'Rajan': 79}
6.
7. >>> del marks['Ravi']
8. >>> marks
9. {'Rohit': 75, 'Rahul': 86, 'Rajan': 79}
10.
11. >>> len(marks)
12. 3
13.
14. >>> fav_books
15. {'Thriller': 'The Da Vinci Code', 'Fantaisie': 'Harry Potter', 'Détective': 'Sherlock
Holmes'}
16. >>> "fantasy" in fav_books
17. True
18. >>> "satire" in fav_books
19. False

• « dict » est composé de listes et utilise un module aléatoire.

- 41 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• Tout changement dans les listes individuelles va renvoyer à « dict ».

• La sortie de la méthode « keys() » doit être changée en types de séquences comme « list » ou « tuple » pour
pouvoir passer à « [Link] ».

1. >>> north = ['aloo tikki', 'baati', 'khichdi', 'makki roti', 'poha']

2. >>> south = ['appam', 'bisibele bath', 'dosa', 'koottu', 'sevai']
3. >>> west = ['dhokla', 'khakhra', 'modak', 'shiro', 'vada pav']
4. >>> east = ['hando guri', 'litti', 'momo', 'rosgulla', 'shondesh']
5. >>> dishes = {'North': north, 'South': south, 'West': west, 'East': east}
6.
7. >>> import random
8. >>> rand_zone = [Link](tuple([Link]()))
9. >>> rand_dish = [Link](dishes[rand_zone])
10. >>> print("Essayez '{}' speciality '{}' aujourd’hui".format(rand_zone, rand_dish))
11. Essayez 'East' speciality 'rosgulla' aujourd’hui

• À partir de Python v3.7, l’implémentation de « dict » devra conserver l’ordre d’insertion.

• Quelques implémentations comme la référence CPython implementation pour la version 3.6 conservent
aussi l’ordre d’insertion.

1. >>> marks = {'Rahul' : 86, 'Ravi' : 92, 'Rohit' : 75, 'Rajan': 79}
2. >>> marks
3. {'Rahul': 86, 'Ravi': 92, 'Rohit': 75, 'Rajan': 79}
4.
5. >>> for name, mark in [Link]():
6. ... print(f'{name:5s}: {mark}')
7. ...
8. Rahul: 86
9. Ravi : 92
10. Rohit: 75
11. Rajan: 79
12.
13. >>> del marks['Ravi']
14. >>> marks
15. {'Rahul': 86, 'Rohit': 75, 'Rajan': 79}
16.
17. >>> marks['Ranjit'] = 65
18. >>> marks
19. {'Rahul': 86, 'Rohit': 75, 'Rajan': 79, 'Ranjit': 65}

VIII-E - Lecture supplémentaire

• Python docs – dict .

• Python docs – pprint .

IX - Manipulation du texte

Dans ce chapitre, nous allons :

• utiliser les méthodes de chaînes ;

• mettre en oeuvre les expressions régulières ;
• chercher et extraire des séquences ;
• chercher à en remplacer ;
• compiler des expressions régulières ;
• approfondir les expressions régulières.

IX-A - Méthodes de chaînes

• Pour modifier des caractères, utiliser :

- 42 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

• [Link]() pour créer une table de traduction ;

• translate() pour effectuer les modifications de caractères suivant la table de transformation.
• er
Le 1 argument à donner à maketrans() est la chaîne de caractères à remplacer, le deuxième, les caractères
e
de remplacement et le 3 constitue la liste des caractères à supprimer.
• Quelques exemples :

1. >>> greeting = '===== Have a great day ====='

2. >>> [Link]([Link]('=', '-'))
3. '----- Have a great day -----'
4.
5. >>> greeting = '===== Have a great day!! ====='
6. >>> [Link]([Link]('=', '-', '!'))
7. '----- Have a great day -----'
8.
9. >>> import string
10. >>> quote = 'SIMPLICITY IS THE ULTIMATE SOPHISTICATION'
11. >>> tr_table = [Link](string.ascii_uppercase, string.ascii_lowercase)
12. >>> [Link](tr_table)
13. 'simplicity is the ultimate sophistication'
14.
15. >>> sentence = "Thi1s is34 a senten6ce"
16. >>> [Link]([Link]('', '', [Link]))
17. 'This is a sentence'
18. >>> [Link]([Link]('', '', [Link]))
19. ' Have a great day '

• Le code ci-après permet d’enlever les premiers caractères/les derniers/les deux.

• Seuls les caractères consécutifs du début ou de la fin sont enlevés.
• Par défaut, les espaces vides sont supprimés.
• Si plusieurs caractères sont spécifiés, ils sont traités comme un ensemble et toutes les combinaisons
fonctionnent.

1. >>> greeting = ' Have a nice day :) '

2. >>> [Link]()
3. 'Have a nice day :)'
4. >>> [Link]()
5. ' Have a nice day :)'
6. >>> [Link]()
7. 'Have a nice day :) '
8.
9. >>> [Link](') :')
10. 'Have a nice day'
11.
12. >>> greeting = '===== Have a great day!! ====='
13. >>> [Link]('=')
14. ' Have a great day!! '

• Formatage.
• Argument de largeur spécifiant la longueur totale de la sortie.

>>> ' Hello World '.center(40, '*')

'************* Hello World **************'
• Modification de la casse et vérification de celle-ci.

1. >>> sentence = 'thIs iS a saMple StrIng'

2.
3. >>> [Link]()
4. 'This is a sample string'
5.
6. >>> [Link]()
7. 'This Is A Sample String'
8.
9. >>> [Link]()

- 43 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

10. 'this is a sample string'

11.
12. >>> [Link]()
13. 'THIS IS A SAMPLE STRING'
14.
15. >>> [Link]()
16. 'THiS Is A SAmPLE sTRiNG'
17.
18. >>> 'good'.islower()
19. True
20.
21. >>> 'good'.isupper()
22. False
• Vérifier si la saisie est constituée de caractères numériques.

>>> '1'.isnumeric()
True
>>> 'abc1'.isnumeric()
False
>>> '1.2'.isnumeric()
False
• Vérifier si une séquence de caractères est présente ou non.

>>> sentence = 'This is a sample string'

>>> 'is' in sentence
True
>>> 'this' in sentence
False
>>> 'This' in sentence
True
>>> 'this' in [Link]()
True
>>> 'is a' in sentence
True
>>> 'test' not in sentence
True
• Obtenir le nombre d’occurrences dans une séquence.

1. >>> sentence = 'This is a sample string'

2. >>> [Link]('is')
3. 2
4. >>> [Link]('w')
5. 0
6.
7. >>> word = 'phototonic'
8. >>> [Link]('oto')
9. 1
• Vérifier la présence d’une séquence au début ou à la fin d’une chaîne de caractères.

1. >>> sentence
2. 'This is a sample string'
3.
4. >>> [Link]('This')
5. True
6. >>> [Link]('The')
7. False
8.
9. >>> [Link]('ing')
10. True
11. >>> [Link]('ly')
12. False
• Séparer une chaîne de caractères à partir d’un caractère ou une série de caractères.
• Renvoie une liste.
• Pour séparer une chaîne à partir d’une expression régulière, utilisez plutôt [Link]().

1. >>> sentence = 'This is a sample string'

- 44 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

2.
3. >>> [Link]()
4. ['This', 'is', 'a', 'sample', 'string']
5.
6. >>> "oranges:5".split(':')
7. ['oranges', '5']
8. >>> "oranges :: 5".split(' :: ')
9. ['oranges', '5']
10.
11. >>> "a e i o u".split(' ', maxsplit=1)
12. ['a', 'e i o u']
13. >>> "a e i o u".split(' ', maxsplit=2)
14. ['a', 'e', 'i o u']
15.
16. >>> line = '{1.0 2.0 3.0}'
17. >>> nums = [float(s) for s in [Link]('{}').split()]
18. >>> nums
19. [1.0, 2.0, 3.0]
• Joindre des listes de chaînes.

1. >>> str_list
2. ['This', 'is', 'a', 'sample', 'string']
3. >>> ' '.join(str_list)
4. 'This is a sample string'
5. >>> '-'.join(str_list)
6. 'This-is-a-sample-string'
7.
8. >>> c = ' :: '
9. >>> [Link](str_list)
10. 'This :: is :: a :: sample :: string'
• Remplacer des caractères.
• e
Le 3 argument précise combien de fois le remplacement doit être effectué.
• La variable doit être spécifiquement réassignée pour que sa valeur soit changée.

1. >>> phrase = '2 be or not 2 be'

2. >>> [Link]('2', 'to')
3. 'to be or not to be'
4.
5. >>> phrase
6. '2 be or not 2 be'
7.
8. >>> [Link]('2', 'to', 1)
9. 'to be or not 2 be'
10.
11. >>> phrase = [Link]('2', 'to')
12. >>> phrase
13. 'to be or not to be'

X - Gestion des fichiers

Dans ce chapitre, nous traiterons :

• la fonction Open ;
• la lecture de fichiers ;
• l’écriture dans des fichiers ;
• l’édition « à la volée » avec fileinput.

X-A - Fonction Open

• Syntaxe : open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True,

opener=None)

- 45 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

>>> import locale

>>> [Link]()
'UTF-8'

• 3 modes d’ouverture :

• r ouvre les fichiers pour lecture ;

• w ouvre les fichiers pour écriture ;
• a ouvre les fichiers pour ajout.
• Le mode par défaut est le mode texte, les arguments ‘r’ et ‘rt’ sont donc équivalents

• Pour le mode binaire, ce sera ‘rb', 'wb' etc.

• [Link]() donne l’encodage par défaut à utiliser.
• Python docs - open
• Python docs - standard encodings

X-B - Lecture de fichiers

1. #!/usr/bin/python3
2.
3. # Ouvrir le fichier, lire ligne par ligne et l’afficher
4. filename = 'hello_world.py'
5. f = open(filename, 'r', encoding='ascii')
6.
7. print("Contenu de " + filename)
8. print('-' * 30)
9. for line in f:
10. print(line, end='')
11.
12. [Link]()
13.
14. # 'with' est une solution plus simple, qui gère automatiquement la fermeture du fichier.
15. filename = 'while_loop.py'
16.
17. print("\n\nContenu de " + filename)
18. print('-' * 30)
19. with open(filename, 'r', encoding='ascii') as f:
20. for line in f:
21. print(line, end='')

• L’encodage par défaut est habituellement ‘UTF-8’, utilisez ‘ASCII’ quand c’est possible.
• Utiliser with et le nom de gestionnaire de f est une convention répandue.

1. $ ./file_reading.py
2. Contenu de hello_world.py
3. ------------------------------
4. #!/usr/bin/python3
5.
6. print("Hello World")
7.
8.
9. Contenu de while_loop.py
10. ------------------------------
11. #!/usr/bin/python3
12.
13. # demande continuellement une entrée jusqu’à saisie d’un entier positif
14. usr_string = 'not a number'
15. while not usr_string.isnumeric():
16. usr_string = input("Entrez un entier positif : ")

Si le fichier n’existe pas

1. #!/usr/bin/python3
2.

- 46 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

3. with open('[Link]', 'r', encoding='ascii') as f:

4. for line in f:
5. print(line, end='')
6. Erreur si le fichier n’existe pas :
7. $ ./file_reading_error.py
8. Traceback (most recent call last):
9. File "./file_reading_error.py", line 3, in <module>
10. with open('[Link]', 'r', encoding='ascii') as f:
11. FileNotFoundError: [Errno 2] No such file or directory: '[Link]'
12. $ echo $?
13. 1

• Lire le contenu du fichier en entier comme une unique chaîne de texte en utilisant read()

>>> f = open('hello_world.py', 'r', encoding='ascii')

>>> f
<_io.TextIOWrapper name='hello_world.py' mode='r' encoding='ascii'>
>>> print([Link]())
#!/usr/bin/python3

print("Hello World")

• Lire ligne par ligne en utilisant readline()

1. >>> f = open('hello_world.py', 'r', encoding='ascii')

2. >>> print([Link](), end='')
3. #!/usr/bin/python3
4. >>> print([Link](), end='')
5.
6. >>> print([Link](), end='')
7. print("Hello World")
8.
9. >>> [Link]()
10. >>> print([Link](), end='')
11. Traceback (most recent call last):
12. File "<stdin>", line 1, in <module>
13. ValueError: I/O operation on closed file.

• Lire toutes les lignes du fichier en tant que liste en utilisant readlines()

• Veuillez noter la forme plurielle

>>> f = open('hello_world.py', 'r', encoding='ascii')

>>> all_lines = [Link]()
>>> all_lines
['#!/usr/bin/python3\n', '\n', 'print("Hello World")\n']

• Vérifier si le fichier est fermé ou non

>>> f = open('hello_world.py', 'r', encoding='ascii')

>>> [Link]
False

>>> [Link]()
>>> [Link]
True

X-C - Écriture dans des fichiers

#!/usr/bin/python3

with open('new_file.txt', 'w', encoding='ascii') as f:

[Link]("C’est une simple ligne de texte\n")

- 47 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

[Link]("Une autre ligne\n")

• Utilisez la méthode write() pour écrire une chaîne de texte dans le fichier.
• Pour ajouter du texte à un fichier existant, utilisez le mode 'a' plutôt que le mode 'w'

$ ./file_writing.py
$ cat new_file.txt
This is a sample line of text
Yet another line

X-D - Édition « à la volée » avec fileinput

#!/usr/bin/python3

import fileinput

with [Link](inplace=True) as f:
for line in f:
line = [Link]('line of text', 'line')
print(line, end='')

• Les fichiers qui doivent être modifiés sont spécifiés comme arguments de ligne de commande quand le
programme est lancé.
• Notez que la fonction print doit être utilisée au lieu de [Link]
• Avec la lecture par ligne, chaque itération a déjà un caractère de nouvelle ligne, end est alors assigné comme
un caractère vide.
• Python docs - fileinput

$ ./inplace_file_editing.py new_file.txt
$ cat new_file.txt
C’est une simple ligne
Une autre ligne

$ # pour modifier tous les fichiers avec .txt dans le dossier courant, utilisez
$ ./inplace_file_editing.py *.txt

$ # stdin peut aussi être passé en tant qu’entrée inplace est désactivé
$ echo 'a line of text' | ./inplace_file_editing.py
a line

• Spécifier les noms de fichiers et extensions pour les sauvegardes.

# Pour spécifier un nom de fichier dans le programme lui-même

with [Link](inplace=True, files=('[Link]', '[Link]')) as f:

# Pour créer une sauvegarde du fichier original, spécifiez une extension au paramètre backup
with [Link](inplace=True, backup='.bkp') as f:

XI - Arguments de ligne de commande

En attente de traducteur

XII - Gestion des exceptions de débogage

En attente de traducteur

XIII - Docstrings

En attente de traducteur

- 48 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]
 Les bases de la programmation Python par l’exemple par Sundeep Agarwal

XIV - Test

En attente de traducteur

XV - Exercices

En attente de traducteur

XVI - En complément

En attente de traducteur

- 49 -
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
[Link]