Le PYTHON en bref

422 Pages·2013·11.43 MB·French

Le PYTHON
en bref
...
1
2
GALODÉ Alexandre
Le PYTHON
En Bref
...
3
Ce livre a été rédigé sous Libre Office et écrit avec
des polices d'écriture libres. Les exemples ont été conçus
sous Geany sur une distribution Linux Ubuntu.
" La connaissance appartient à tout le monde "
Film Antitrust
Conçu et rédigé par Alexandre GALODÉ.
Ouvrage placé sous licence Creative Commons BY-NC-SA.
Texte complet de la licence depuis http://creativecommons.fr/licences/les-6-licences/
4
Ce livre est dédié à ma fiancée, mes parents, ma
famille, mon " frère " et mes amis, présents ou
regrettés.
5
6
SOMMAIRE
Introduction...................................................................................27
1 Présentation...............................................................................29
1.1 Langages compilés et interprétés......................................30
1.2 Le langage PYTHON en bref...............................................31
2 La Programmation Orientée Objet...........................................33
2.1 Définition..............................................................................34
2.2 Les objets par l'exemple.....................................................35
2.2.1 Les classes.................................................................................35
2.2.2 Les propriétés............................................................................35
2.2.3 Les méthodes............................................................................36
2.2.4 En bref.........................................................................................36
2.3 L'encapsulation....................................................................37
2.4 L’héritage..............................................................................38
3 Le langage PYTHON..................................................................41
3.1 Les types de données.........................................................42
3.1.1 Booléens.....................................................................................42
3.1.2 Integer.........................................................................................42
3.1.3 Long............................................................................................42
3.1.4 Float............................................................................................43
3.1.5 String...........................................................................................43
3.1.5.1 Méthodes.............................................................................................44
3.1.6 Liste.............................................................................................46
7
3.1.6.1 Méthodes.............................................................................................47
3.1.7 Dictionnaire................................................................................47
3.1.7.1 Méthodes.............................................................................................48
3.1.8 Tuple...........................................................................................48
3.2 Le transtypage.....................................................................49
3.2.1 Transtypage de type..................................................................49
3.2.2 Transtypage de format..............................................................49
4.7.3 Détection de la plateforme d'exécution...................................50
3.3 La portée des variables.......................................................51
3.4 Quelques fonctions prédéfinies.........................................52
3.4.1 PRINT..........................................................................................52
3.4.2 LEN..............................................................................................52
3.4.3 TYPE............................................................................................52
3.4.4 INPUT..........................................................................................53
3.4.5 GETPASS....................................................................................53
3.5 Le caractère de césure........................................................54
3.6 Le caractère de commentaire.............................................55
3.7 Les opérateurs.....................................................................56
3.8 Les tests conditionnels.......................................................57
3.8.1 IF, ELIF, ELSE.............................................................................57
3.9 Les boucles..........................................................................58
3.9.1 FOR.............................................................................................58
3.9.2 WHILE.........................................................................................59
3.9.3 Break et continue.......................................................................59
3.10 PYTHON et les fichiers......................................................60
8
3.10.1 Chemin absolu et chemin relatif...........................................60
3.10.2 Ouverture d'un fichier.............................................................60
3.10.3 Fermeture d'un fichier.............................................................61
3.10.4 Lecture......................................................................................61
3.10.5 Écriture.....................................................................................63
3.11 La POO PYTHON................................................................64
3.11.1 PYTHON et les principes de la POO.....................................64
3.11.1.1 L'encapsulation.................................................................................64
3.11.1.2 L'héritage...........................................................................................64
3.11.2 La modularité avec PYTHON..................................................64
3.11.2.1 L'instruction import..........................................................................64
3.11.2.2 L'instruction SELF............................................................................65
3.11.2.3 Les fonctions et les procédures......................................................65
3.11.2.4 Les classes........................................................................................66
3.11.2.4.1 Les attributs................................................................................67
3.11.2.4.2 Les accesseurs..........................................................................68
3.11.2.4.3 Les mutateurs.............................................................................68
3.11.2.4.4 Mise en situation........................................................................68
3.11.2.5 Les modules......................................................................................70
3.11.2.6 Les packages....................................................................................71
3.11.2.6.1 Composition d'un package........................................................71
3.11.2.7 En résumé..........................................................................................71
3.11.3 Stockage d'objet dans des fichiers.......................................73
3.11.3.1 Lecture...............................................................................................73
3.11.3.2 Enregistrement..................................................................................73
3.12 Les expressions régulières...............................................74
3.12.1 Le module re............................................................................75
3.12.1.1 Search................................................................................................75
9
3.12.1.2 Sub......................................................................................................76
3.13 Les exceptions...................................................................77
3.14 Les mots réservés.............................................................79
3.15 Convention de programmation........................................80
3.15.1 La PEP20...................................................................................80
3.15.2 La PEP8.....................................................................................81
3.15.3 Règles de codage....................................................................81
3.15.3.1 Les variables.....................................................................................82
3.15.3.2 Les fonctions/procédures................................................................82
3.15.3.3 Les modules et packages................................................................82
3.15.3.4 Les classes........................................................................................82
3.15.3.4.1 Le nom des classes...................................................................82
3.15.3.4.2 Les propriétés et les méthodes................................................82
3.15.3.5 Les exceptions..................................................................................82
3.15.3.6 Les DocStrings..................................................................................83
3.15.3.7 Début de code....................................................................................83
3.15.3.8 Sortie de code....................................................................................84
3.15.3.9 Autre...................................................................................................84
3.15.3.10 En plus.............................................................................................85
3.15.4 Bonne structure type d'un programme.................................86
3.15.4.1 La mise en page................................................................................87
3.15.4.2 Les règles..........................................................................................87
4 Modules Complémentaires.......................................................89
4.1 Pypi.......................................................................................90
4.2 Le temps...............................................................................91
4.2.1 Le timestamp.............................................................................91
4.2.2 Date complète............................................................................91
10