Système d`Information et programmation

Système d'Information et programmation
Programmation Python
Manipulation de données
http://www.agroparistech.fr/Donnees-et-Programmation.html
Christine MARTIN
UFR d'Informatique
Département MMIP
[e-mail]
AgroParisTech Massy 1A apprentis
Année 2015-2016

2

3
Table des matières
1 Introduction ................................................................................................................................5
1.1 Contexte, organisation et objectifs du module .....................................................................5
1.2 Choix du langage de programmation : pourquoi Python ......................................................5
1.3 Installer Python ...................................................................................................................6
2 Premiers programmes .................................................................................................................7
2.1 Environnement de développement......................................................................................7
2.2 Un exemple .........................................................................................................................8
3 Premiers pas en Python ............................................................................................................. 10
3.1 Données, types et variables ............................................................................................... 10
3.1.1 Définitions et syntaxe ................................................................................................ 10
3.1.2 Les types prédéfinis ................................................................................................... 10
3.1.3 Conversion de types ................................................................................................... 11
3.1.4 Variables et affectation (ou assignation) .................................................................... 12
3.1.5 Afficher la valeur d'une ou plusieurs variables ............................................................ 12
3.1.6 Opérateurs et expressions ......................................................................................... 13
3.2 Interactions avec l'utilisateur : les fonctions input() et raw_input() .................................... 15
3.3 Sélection ou exécution conditionnelle ............................................................................... 16
3.4 Instructions et blocs .......................................................................................................... 17
3.5 Les fonctions ..................................................................................................................... 18
3.6 Importer un module de fonctions ...................................................................................... 22
3.7 Structure générale d'un script Python ................................................................................ 25
4 Boucles et séquences ................................................................................................................ 27
4.1 Répétitions en boucle - l'instruction while ......................................................................... 27
4.2 Les séquences.................................................................................................................... 29
4.3 Utilisation des chaînes de caractères ................................................................................. 30
4.4 Les listes ............................................................................................................................ 35
4.5 Conversions liste – chaîne de caractères ............................................................................ 36
4.6 Retour sur l'affectation ...................................................................................................... 39
5 Programmation de graphiques - séquences ............................................................................... 41
5.1 Présentation des bibliothèques ......................................................................................... 41
5.1.1 La bibliothèque random ............................................................................................. 41
5.1.2 La bibliothèque matplotlib ......................................................................................... 42
6 Manipulation des Fichiers ......................................................................................................... 57

4
6.1 Ouvrir un fichier ................................................................................................................ 57
6.2 Fermer un fichier ............................................................................................................... 57
6.3 Méthodes de lecture ......................................................................................................... 57
6.4 Méthodes d’écriture : ........................................................................................................ 58
6.5 Méthodes seek et tell ....................................................................................................... 58
6.6 Mise en pratique ............................................................................................................... 59
7 Programmation de graphique - fichiers ..................................................................................... 61
8 Les bases de données et le langage SQL .................................................................................... 63
8.1 Quelques définitions .......................................................................................................... 64
8.2 La notion de clé ................................................................................................................. 67
8.2.1 Clé primaire ............................................................................................................... 67
8.2.2 Clé étrangère ............................................................................................................. 67
8.3 Contraintes d'intégrité ....................................................................................................... 68
8.4 Schéma et contenu ............................................................................................................ 69
8.5 Le langage SQL (Structured Query Language) ..................................................................... 71
8.5.1 Consulter les données stockées dans une base de données existante ........................ 71
8.5.2 Ajouter des données dans une table .......................................................................... 82
8.5.3 Supprimer des données dans une table ...................................................................... 83
8.5.4 Modifier le contenu d'une table ................................................................................. 83
8.5.5 Créer une base de données ........................................................................................ 86
8.5.6 Créer / Supprimer/ Modifier la structure d'une table ................................................. 86
9 Interaction avec des bases de données en Python ..................................................................... 89
9.1 Se connecter à une base de données SQLite en Python...................................................... 89
9.2 Interroger une base de données SQLite en Python............................................................. 90
9.3 Interrogation contextuelle ................................................................................................. 91
9.4 Se déconnecter d'une base de données SQLite en Python ................................................. 91
9.5 Insertions et suppressions ................................................................................................. 93
9.6 Création du schéma d'une base de données depuis un programme Python ....................... 94
10 Projet .................................................................................................................................... 95

5
Séance 1
1 Introduction
1.1 Contexte, organisation et objectifs du module
Issu des domaines de l'informatique et des télécommunications, le concept de Système
d’Information a envahi l'ensemble des organisations privées ou publiques quel que soit leur domaine
d’intérêt. Le terme système d'information (ou SI) est notamment défini comme un ensemble
organisé de ressources (personnel, données, procédures, matériel, logiciel, ...) permettant d'acquérir,
de stocker, de structurer et de communiquer des informations (de formats divers) nécessaires au
bon fonctionnement de l’organisme concerné. Connaître, comprendre, savoir utiliser voire créer de
tels systèmes est désormais indispensable à tout ingénieur.
Lors de ce module, vous apprendrez les bases de la programmation dans un des langages
informatiques les plus utilisés à l'heure actuelle (Python) et comment un programme peut exploiter
des données de différentes provenances notamment de bases de données (outils au cœur des
systèmes d'information) que nous définirons à cette occasion.
Ce module vous apportera des connaissances tantôt génériques tantôt plus spécifiques et
indispensables à tout futur ingénieur et notamment vous apprendra à :
 structurer, modéliser, interroger ses données,
 décomposer un problème,
 définir l'algorithme résolvant un problème précis,
 implémenter un algorithme dans un langage donné,
 présenter des résultats.
Ce module se compose de 27h d'enseignement réparties en 9 séances de 3h. Les 7 premières
séances seront consacrées à du Cours/ TD tandis que les 2 dernières permettront la réalisation d'un
projet en binôme sur lequel vous serez évalués.
1.2 Choix du langage de programmation : pourquoi Python
Les avantages de Python sont nombreux, c’est un langage :
 facile à apprendre, à lire, à comprendre et à écrire ;
 avec une syntaxe sobre ;
 portable (fonctionne sous de nombreux systèmes d'exploitation) ;
 dynamique ;
 extensible ;
 gratuit ;
 qui permet (sans l'imposer)
o une approche modulaire (découpage d'un programme en sous-unités) ;