Les bases de la programmation Python par l’exemple

Sundeep Agarwal

Traducteurs

| Laethy | Nothus | Petit Vince |

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

Commentez

- Titre : Les bases de la programmation Python par l’exemple

- Auteur : Sundeep Agarwal

- Traducteurs : Laethy, Nothus, Petit Vince

- Parution : 31 août 2018

- Mise à jour : 30 mars 2021

- Licence : 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.

Sommaire

- I. Introduction

- I-A. Installation

- I-B. Exemple Hello World

- I-C. Exécution du programme Python

- I-D. Pour plus d’information

- I-E. L’interpréteur Python

- I-F. Lectures complémentaires

- I-G. Bibliothèque standard Python

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

- II-A. Les types numériques

- II-A-1. Lectures complémentaires

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

- II-C. Les constantes

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

- II-E. Lectures complémentaires

- III. Les fonctions

- III-A. Définition d'une fonction

- III-B. Valeur par défaut des arguments

- III-C. Lectures complémentaires

- III-D. Fonction print

- III-E. Fonction range

- III-F. Fonction déterminant le type

- III-G. Portée des variables

- III-H. Lectures complémentaires

- IV. Obtenir une entrée utilisateur

- IV-A. Entrée d’entiers

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

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

- V. Exécution des commandes externes

- V-A. Appel de commandes Shell

- V-B. Appel de commandes Shell avec expansion

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

- VI. Structures de contrôle

- VI-A. Vérification de la condition

- VI-B. if

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

- VI-D. for

- VI-E. while

- VI-F. continue and break

- VII. Les listes

- VII-A. Assignation des variables de liste

- VII-B. Découpage et modification des listes

- VII-C. Copie des listes

- VII-D. Méthodes de liste et divers

- VII-E. Lecture complémentaire

- VII-F. Les boucles

- VII-G. Compréhension d’une liste

- VII-H. Lecture complémentaire

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

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

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

- VIII-A. Chaînes

- VIII-B. Tuples

- VIII-C. Ensemble

- VIII-D. Dictionnaire

- VIII-E. Lecture supplémentaire

- IX. Manipulation du texte

- IX-A. Méthodes de chaînes

- X. Gestion des fichiers

- X-A. Fonction Open

- X-B. Lecture de fichiers

- X-C. Écriture dans des fichiers

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

- XI. Arguments de ligne de commande

- XII. Gestion des exceptions de débogage

- XIII. Docstrings

- XIV. Test

- XV. Exercices

- XVI. En complément

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 Developpez.com.

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.

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

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

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

9. # Pas de limite à la précision des nombres entiers, uniquement limitée par la mémoire disponible

10. >>> 34 ** 32

11. 10170102859315411774579628461341138023025901305856

13. # L’utilisation d’une barre oblique simple / produit un résultat à virgule flottante

14. >>> 9 / 5

15. 1.8

17. # L’utilisation de barres obliques doubles // ne donne que la partie entière du résultat sans arrondi

18. >>> 9 // 5

19. 1

21. >>> 9 % 5

22. 4

- Exemples sur les nombres à virgule flottante :

1. >>> appx_pi = 22 / 7

2. >>> appx_pi

3. 3.142857142857143

5. >>> area = 42.16

6. >>> appx_pi + area

7. 45.30285714285714

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

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

2. >>> oct_num = 0o12

3. >>> hex_num = 0xF

5. >>> bin_num

6. 5

7. >>> oct_num

8. 10

9. >>> hex_num

10. 15

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

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!'

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

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

3. 'Blue\nRed\nGreen'

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

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

6. >>> style_char = '-'

7. >>> style_char * 10

8. '----------'

10. >>> word = 'buffalo '

11. >>> print(word * 8)

12. buffalo buffalo buffalo buffalo buffalo buffalo buffalo buffalo

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

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. """

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. """

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,

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

- 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

3. # ----- Fonction sans argument -----

4. def greeting():

5. print("-----------------------------")

6. print("         Hello World         ")

7. print("-----------------------------")

9. greeting()

11. # ----- Fonction avec arguments -----

12. def somme_deux_nombres(num1, num2):

13. total = num1 + num2

14. print("{} + {} = {}".format(num1, num2, total))

16. somme_deux_nombres(3, 4)

18. # ----- Fonction avec une valeur de retour -----

19. def carre(num):

20. return num * num

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. $ ./functions.py

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

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)

9. print("Style par défaut")

10. greeting()

12. print("\ncarctère de style  *")

13. greeting('*')

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. -----------------------------

7. Si le style passé est "*"

8. *****************************

9. Hello World

10. *****************************

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. """

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 :

- 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)

3. Help on built-in function print in module builtins:

5. print(...)

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

8. Prints the values to a stream, or to sys.stdout by default.

9. Optional keyword arguments:

10. file:  a file-like object (stream); defaults to the current sys.stdout.

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

4. >>> print(a+b, a-b)

5. 7 3

7. >>> print(a+b, a-b, sep=' : ')

8. 7 : 3

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

8. >>> print(greeting + '. We are learning Python')

9. Hello World. We are learning Python

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

11. Hello World. We are learning Python

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

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

4. >>> items = 15

5. >>> print("No. of items:", items)

6. No. of items: 15

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 sys.exit().

1. >>> import sys

2. >>> print("Error!! Not a valid input", file=sys.stderr)

3. Error!! Not a valid input

- La fonction str.format() 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

4. >>> '{} + {} = {}'.format(num1, num2, num1 + num2)

5. '42 + 7 = 49'

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'

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

3. 3.142857142857143

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

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

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

8. # add # for 0b/0o/0x prefix

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

10. 42 in binary = 0b101010

12. >>> hex_str = "{:x}".format(42)

13. >>> hex_str

14. '2a'

16. # can also use format built-in function

17. >>> format(42, 'x')

18. '2a'

19. >>> format(42, '#x')

20. '0x2a'

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 à str.format(), 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

8. >>> appx_pi = 22 / 7

9. >>> f'{appx_pi:08.3f}'

10. '0003.143'

12. >>> f'{20:x}'

13. '14'

14. >>> f'{20:#x}'

15. '0x14'

Lectures complémentaires :

- 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)

4. >>> list(range(5))

5. [0, 1, 2, 3, 4]

7. >>> list(range(-2, 2))

8. [-2, -1, 0, 1]

10. >>> list(range(1, 15, 2))

11. [1, 3, 5, 7, 9, 11, 13]

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'>

4. >>> type('Hi there!')

5. <class 'str'>

7. >>> type(range(7))

8. <class 'range'>

10. >>> type(None)

11. <class 'NoneType'>

13. >>> type(True)

14. <class 'bool'>

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

3. def print_num():

4. print("Yeehaw! num is visible in this scope, its value is: " + str(num))

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

3. def square_of_num(num):

4. sqr_num = num * num

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

3. def square_of_num(num):

4. global sqr_num

5. sqr_num = num * num

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

3. sqr_num = 4

5. def square_of_num(num):

6. sqr_num = num * num

7. print("5 * 5 = {}".format(sqr_num))

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

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

3. usr_ip = input("Enter an integer number: ")

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

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

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

3. usr_ip = input("Enter a floating point number: ")

5. # Need to explicitly convert input string to desired type

6. usr_num = float(usr_ip)

7. sqr_num = usr_num * usr_num

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

5. $ ./user_input_float.py

6. Enter a floating point number: 42.7e5

7. Square of entered number is: 18232900000000.00

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

3. usr_name  = input("Hi there! What's your name? ")

4. usr_color = input("And your favorite color is? ")

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

3. import subprocess

5. # Exécuter la commande externe 'date'

6. subprocess.call('date')

8. # Passer  des options et des arguments à la commande

9. print("\nToday is ", end="", flush=True)

10. subprocess.call(['date', '-u', '+%A'])

12. # Autre exemple

13. print("\nSearching for 'hello world'", flush=True)

14. subprocess.call(['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 subprocess.call.

- 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

4. Today is Tuesday

6. Searching for 'hello world'

7. print("Hello World")

Lecture complémentaire :

- documentation Python – module subprocess ;

- documentation Python – os.system ;

- différence os.system et subprocess.call ;

- 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)
subprocess.call(['echo', 'Hello $USER'])

# Exécution avec l’expansion Shell
print("\nexpansionshell  quand shell=True", flush=True)
subprocess.call('echo Hello $USER', shell=True)

# Echappement de la chaîne si nécessaire
print("\nSearching for 'hello world'", flush=True)
subprocess.call('grep -i \'hello world\' hello_world.py', shell=True)

- Par défaut subprocess.call 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

5. expansion shell quand shell=True

6. Hello learnbyexample

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
subprocess.call('grep -i "hello world" hello_world.py', shell=True)

# ou ceci
subprocess.call("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' report.log test_list.txt > grep_test.txt"
subprocess.call(cmd, shell=True)

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

>>> import subprocess, os
>>> subprocess.call(['echo', 'Hello', os.environ.get("USER")])
Hello learnbyexample
0

- os.environ.get("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 = subprocess.getoutput('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 xyz.py'
print("\nAppel de la  commande '{}'".format(ls_command), flush=True)
(ls_status, ls_output) = subprocess.getstatusoutput(ls_command)
print("status: {}\nsortie : '{}'".format(ls_status, ls_output))

# Vous pouvez supprimer les messages d’erreurs si vous le souhaitez
# subprocess.call() renvoie le statut de la commande et qui peut être utilisé
print("\nCalling command with error msg suppressed", flush=True)
ls_status = subprocess.call(ls_command, shell=True, stderr=subprocess.DEVNULL)
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 subprocess.run.

$ ./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 xyz.py'
status: 2
sortie : 'ls: cannot access xyz.py: No such file or directory
hello_world.py'

Appel de la commande avec messages d'erreur supprimés
hello_world.py
status: 2

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):
...         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

3. num = 45

5. # only if

6. if num > 25:

7. print("Hourra! {} est plus grand que 25".format(num))

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))

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

3. num = 42

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.

1. $ ./if_else_oneliner.py

2. 42 est un nombre pair

VI-D - for

1. #!/usr/bin/python3

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

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

3. prev_num = 0

4. curr_num = 0

5. print("Les dix premiers nombres de la suite de Fibonacci: ", end='')

8. for num in range(10):

9. print(curr_num, end=' ')

11. if num == 0:

12. curr_num = 1

13. continue

15. temp = curr_num

16. curr_num = curr_num + prev_num

17. prev_num = temp

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

3. import random

5. while True:

6. # comme avec la fonction range(), 500 n’est pas inclus

7. random_int = random.randrange(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

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.

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

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']

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"]

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]

14. >>> prime[-1]

15. 11

16. >>> prime[-1:]

17. [11]

18. >>> prime[-2:]

19. [7, 11]

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]

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]

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

9. # l’affectation sans utiliser [:] changera son id

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

11. >>> id(nums)

12. 140598782943752

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

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]

13. >>> list_2D = [[1, 3, 2, 10], [1.2, -0.2, 0, 2]]

14. >>> a = list_2D[:]

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 = copy.deepcopy(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. >>> books.append('Harry Potter')

5. >>> books

6. ['Harry Potter']

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]

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]

18. >>> a = [[1, 3], [2, 4]]

19. >>> a.extend([[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. >>> prime.pop()

3. 11

4. >>> prime

5. [2, 3, 5, 7]

6. >>> prime.pop(0)

7. 2

8. >>> prime

9. [3, 5, 7]

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]]

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]

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]]

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. >>> prime.clear()

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: list.remove(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. >>> books.insert(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

4. >>> 13 in prime

5. False

- Tri.

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

2. >>> a.sort()

3. >>> a

4. [0, 1, 1, 2, 5.3, 321]

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

7. >>> a.sort(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.
Les 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. >>> words.sort(key=len)

3. >>> words

4. ['irk', 'seam', 'crusado', 'morello', 'fuliginous']

6. >>> words.sort(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]

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. >>> nums.count(99)

3. 1

4. >>> nums.count(19)

5. 2

6. >>> nums.count(23)

7. 0

- Liste inversée

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

2. >>> id(prime)

3. 140684818102088

4. >>> prime.reverse()

5. >>> prime

6. [11, 7, 5, 3, 2]

7. >>> id(prime)

8. 140684818102088

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

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

7. >>> conditions[1] = True

8. >>> all(conditions)

9. True

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

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

8. False

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

10. True

VII-E - Lecture complémentaire

- Python docs - more on lists.

- Python docs – collections .

VII-F - Les boucles

1. #!/usr/bin/python3

3. numbers = [2, 12, 3, 25, 624, 21, 5, 9, 12]

4. odd_numbers  = []

5. even_numbers = []

7. for num in numbers:

8. odd_numbers.append(num) if(num % 2) else even_numbers.append(num)

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

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

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

- 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

3. import time

5. numbers = list(range(1,100001))

6. fl_square_numbers = []

8. # référencer time

9. t0 = time.perf_counter()

11. # ------------ la boucle for ------------

12. for num in numbers:

13. fl_square_numbers.append(num * num)

15. # référencer time

16. t1 = time.perf_counter()

18. # ------- compréhension de la liste -------

19. lc_square_numbers = [num * num for num in numbers]

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

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))

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%

6. fl_square_numbers et lc_square_numbers sont équivalents

- Compréhension de la liste conditionnelle.

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]

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']

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]

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. >>> random.choice(a)

4. 76

5. >>> random.choice(a)

6. 4

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

1. >>> random.shuffle(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. >>> random.sample(a, k=3)

2. [76, 2, 5]

4. >>> random.sample(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. >>> random.shuffle(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 - random.choices.

- 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"

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

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'

24. >>> list(book)

25. ['A', 'l', 'c', 'h', 'e', 'm', 'i', 's', 't']

27. >>> import string

28. >>> string.ascii_lowercase[:10]

29. 'abcdefghij'

30. >>> list(string.digits)

31. ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

- Boucles sur chaînes.

1. >>> book

2. 'Alchemist'

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'

4. >>> len(book)

5. 9

7. >>> book.index('A')

8. 0

9. >>> book.index('t')

10. 8

12. >>> 'A' in book

13. True

14. >>> 'B' in book

15. False

16. >>> 'z' not in book

17. True

19. >>> min('zealous')

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')

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

14. >>> north_dishes[::-1]

15. ('Poha', 'Makki roti', 'Khichdi', 'Baati', 'Aloo tikki')

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

6. >>> len(north_dishes)

7. 5

9. >>> min(north_dishes)

10. 'Aloo tikki'

11. >>> max(north_dishes)

12. 'Poha'

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

9. >>> c = 'foo'

10. >>> a, b, c = c, a, b

11. >>> a

12. 'foo'

13. >>> b

14. 20

15. >>> c

16. 5

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')

5. >>> coordinates = ((1,2), (4,3), (92,3))

6. >>> coordinates

7. ((1, 2), (4, 3), (92, 3))

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')

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')]

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

3. {1, 2, 3, 5, 6.3, 7}

5. >>> primes = {3, 2, 11, 3, 5, 13, 2}

6. >>> primes

7. {2, 3, 11, 13, 5}

9. >>> nums.union(primes)

10. {1, 2, 3, 5, 6.3, 7, 11, 13}

12. >>> primes.difference(nums)

13. {11, 13}

14. >>> nums.difference(primes)

15. {1, 6.3, 7}

- Exemples d’opérations.

1. >>> len(nums)

2. 6

4. >>> nums[0]

5. Traceback (Dernier appel passé):

6. File "<stdin>", line 1, in <module>

7. TypeError: 'set' object does not support indexing

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]

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

19. >>> nums

20. {1, 2, 3, 5, 6.3, 7}

21. >>> nums.pop()

22. 1

23. >>> nums

24. {2, 3, 5, 6.3, 7}

26. >>> nums.add(1)

27. >>> nums

28. {1, 2, 3, 5, 6.3, 7}

30. >>> 6.3 in nums

31. True

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.

- 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}

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'}

12. >>> marks.keys()

13. dict_keys(['Ravi', 'Rohit', 'Rahul'])

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

8. >>> for name, mark in marks.items():

9. ...     print(name, mark, sep=' : ')

10. ...

11. Ravi: 92

12. Rohit: 75

13. Rahul: 86

15. >>> import pprint

16. >>> pp = pprint.PrettyPrinter(indent=4)

17. >>> pp.pprint(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}

7. >>> del marks['Ravi']

8. >>> marks

9. {'Rohit': 75, 'Rahul': 86, 'Rajan': 79}

11. >>> len(marks)

12. 3

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.

- 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 à « random.choice ».

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}

7. >>> import random

8. >>> rand_zone = random.choice(tuple(dishes.keys()))

9. >>> rand_dish = random.choice(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}

5. >>> for name, mark in marks.items():

6. ...     print(f'{name:5s}: {mark}')

7. ...

8. Rahul: 86

9. Ravi : 92

10. Rohit: 75

11. Rajan: 79

13. >>> del marks['Ravi']

14. >>> marks

15. {'Rahul': 86, 'Rohit': 75, 'Rajan': 79}

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 :

- str.maketrans() pour créer une table de traduction ;

- translate() pour effectuer les modifications de caractères suivant la table de transformation.

- Le 1er argument à donner à maketrans() est la chaîne de caractères à remplacer, le deuxième, les caractères de remplacement et le 3e constitue la liste des caractères à supprimer.

- Quelques exemples :

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

2. >>> greeting.translate(str.maketrans('=', '-'))

3. '----- Have a great day -----'

5. >>> greeting = '===== Have a great day!! ====='

6. >>> greeting.translate(str.maketrans('=', '-', '!'))

7. '----- Have a great day -----'

9. >>> import string

10. >>> quote = 'SIMPLICITY IS THE ULTIMATE SOPHISTICATION'

11. >>> tr_table = str.maketrans(string.ascii_uppercase, string.ascii_lowercase)

12. >>> quote.translate(tr_table)

13. 'simplicity is the ultimate sophistication'

15. >>> sentence = "Thi1s is34 a senten6ce"

16. >>> sentence.translate(str.maketrans('', '', string.digits))

17. 'This is a sentence'

18. >>> greeting.translate(str.maketrans('', '', string.punctuation))

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. >>> greeting.strip()

3. 'Have a nice day :)'

4. >>> greeting.rstrip()

5. '      Have a nice day :)'

6. >>> greeting.lstrip()

7. 'Have a nice day :)     '

9. >>> greeting.strip(') :')

10. 'Have a nice day'

12. >>> greeting = '===== Have a great day!! ====='

13. >>> greeting.strip('=')

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'

3. >>> sentence.capitalize()

4. 'This is a sample string'

6. >>> sentence.title()

7. 'This Is A Sample String'

9. >>> sentence.lower()

10. 'this is a sample string'

12. >>> sentence.upper()

13. 'THIS IS A SAMPLE STRING'

15. >>> sentence.swapcase()

16. 'THiS Is A SAmPLE sTRiNG'

18. >>> 'good'.islower()

19. True

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 sentence.lower()
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. >>> sentence.count('is')

3. 2

4. >>> sentence.count('w')

5. 0

7. >>> word = 'phototonic'

8. >>> word.count('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'

4. >>> sentence.startswith('This')

5. True

6. >>> sentence.startswith('The')

7. False

9. >>> sentence.endswith('ing')

10. True

11. >>> sentence.endswith('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 re.spit().

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

3. >>> sentence.split()

4. ['This', 'is', 'a', 'sample', 'string']

6. >>> "oranges:5".split(':')

7. ['oranges', '5']

8. >>> "oranges :: 5".split(' :: ')

9. ['oranges', '5']

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']

16. >>> line = '{1.0 2.0 3.0}'

17. >>> nums = [float(s) for s in line.strip('{}').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'

8. >>> c = ' :: '

9. >>> c.join(str_list)

10. 'This :: is :: a :: sample :: string'

- Remplacer des caractères.

- Le 3e 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. >>> phrase.replace('2', 'to')

3. 'to be or not to be'

5. >>> phrase

6. '2 be or not 2 be'

8. >>> phrase.replace('2', 'to', 1)

9. 'to be or not 2 be'

11. >>> phrase = phrase.replace('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)

>>> import locale
>>> locale.getpreferredencoding()
'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.

- locale.getpreferredencoding() donne l’encodage par défaut à utiliser.

- Python docs - open

- Python docs - standard encodings

X-B - Lecture de fichiers

1. #!/usr/bin/python3

3. # Ouvrir le fichier, lire ligne par ligne et l’afficher

4. filename = 'hello_world.py'

5. f = open(filename, 'r', encoding='ascii')

7. print("Contenu de " + filename)

8. print('-' * 30)

9. for line in f:

10. print(line, end='')

12. f.close()

14. # 'with' est une solution plus simple, qui gère automatiquement la fermeture du fichier.

15. filename = 'while_loop.py'

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

6. print("Hello World")

9. Contenu de while_loop.py

10. ------------------------------

11. #!/usr/bin/python3

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

3. with open('xyz.py', '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('xyz.py', 'r', encoding='ascii') as f:

11. FileNotFoundError: [Errno 2] No such file or directory: 'xyz.py'

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(f.read())
#!/usr/bin/python3

print("Hello World")

- Lire ligne par ligne en utilisant readline()

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

2. >>> print(f.readline(), end='')

3. #!/usr/bin/python3

4. >>> print(f.readline(), end='')

6. >>> print(f.readline(), end='')

7. print("Hello World")

9. >>> f.close()

10. >>> print(f.readline(), 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 = f.readlines()
>>> 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')

>>> f.closed
False

>>> f.close()
>>> f.closed
True

X-C - Écriture dans des fichiers

#!/usr/bin/python3

with open('new_file.txt', 'w', encoding='ascii') as f:
f.write("C’est une simple ligne de texte\n")
f.write("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 fileinput.input(inplace=True) as f:
for line in f:
line = line.replace('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 f.write

- 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 fileinput.input(inplace=True, files=('file1.txt', 'file2.txt')) as f:

# Pour créer une sauvegarde du fichier original, spécifiez une extension au paramètre backup
with fileinput.input(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

XIV - Test

En attente de traducteur

XV - Exercices

En attente de traducteur

XVI - En complément

En attente de traducteur