Dans ce cours, on découvre comment construire une interface graphique en Python en utilisant la librairie Tk. Après avoir vu les différents composants de base, ce cours présente la programmation évènementielle qui permet d'écrire du code qui réagit à des évènements comme le clic sur un bouton, par exemple.
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Objectif général : Acquérir les connaissances nécessaires à la programmation avec le langage Python
Objectifs opérationnels :
- Mémoriser des données primitives
- Traiter des données
- Communiquer avec l’extérieur
- Contrôler le flux d’exécution des instructions
- Mémoriser des données composites
- Découper et réutiliser du code
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Objectif général : Acquérir les connaissances nécessaires à la programmation avec le langage Python
Objectifs opérationnels :
- Mémoriser des données primitives
- Traiter des données
- Communiquer avec l’extérieur
- Contrôler le flux d’exécution des instructions
- Mémoriser des données composites
- Découper et réutiliser du code
cours d'initiation à la programmation modulaire sous Python en utilisant des fonctions et des procédures pour décomposer un problème en sous-problème plus facile à traiter en utilisant des fonctions et des procédures.
Dans ce cours, on découvre comment lire et écrire des fichiers à l'aide de Python. Il est possible de créer des fichiers texte ou des fichiers binaires. Pour manipuler un fichier, il faut d'abord l'ouvrir, puis on peut faire les opérations et enfin on doit le refermer.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Cette présentation concerne la mesure des distances entre la Terre et les étoiles. Elle présente notamment la technique du l'écho radar et celle de la parallaxe.
cours d'initiation à la programmation modulaire sous Python en utilisant des fonctions et des procédures pour décomposer un problème en sous-problème plus facile à traiter en utilisant des fonctions et des procédures.
Dans ce cours, on découvre comment lire et écrire des fichiers à l'aide de Python. Il est possible de créer des fichiers texte ou des fichiers binaires. Pour manipuler un fichier, il faut d'abord l'ouvrir, puis on peut faire les opérations et enfin on doit le refermer.
Ce cours concerne la manipulation des chaines de caractères et les expressions régulières. La première partie présente la classe str Python ainsi que les opérations qu'il est possible de faire sur des objets str. La seconde partie concerne les expressions regulières qui permettent de valider des chaines de caractères ou d'en extraire des sous-chaines qui satisfont un motif donné. On y voit finalement comment utiliser le module re Python.
Cette présentation concerne la mesure des distances entre la Terre et les étoiles. Elle présente notamment la technique du l'écho radar et celle de la parallaxe.
Ce cours présente les relations de composition et d'agrégation qu'il est possible d'établir entre plusieurs classes et objets. La seconde partie présente la notion d'immuabilité d'objets et montre comment faire des copies d'objets.
Ce deuxième cours concerne les tuples, séquences non modifiables d'éléments. On peut les étendre en tuples nommés en ajoutant un nom à chacune des entrées du tuple, appelées alors champs. Enfin, on peut aller plus loin et définir des objets en associant des fonctions à des données. Cette seconde partie introduit à la programmation orientée objet.
Présentation du projet de transmission numérique dans lequel les étudiants sont amenés, en équipes mixtes électroniciens - informaticiens, à développer une application qui, sur base de données collectées par des senseurs, propose une analyse de ces dernières pour fournir un service.
Slides du cours "JAVA1001 : Introduction à la programmation Java" de la formation "Apprendre Java et la Programmation Orientée-Objets" du learning center de http://www.ukonline.be
Ce deuxième cours aborde la programmation réseau, c'est-à-dire le développement d'applications avec plusieurs composants qui communiquent entre eux via la réseau. Après une rapide présentation des protocoles UDP et TCP, le cours aborde la notion de socket et présente le module Python de même nom. Le cours présente deux applications concrètes : une application de chat (basé sur UDP) et une application echo (basé sur TCP). Le cours se termine par la découverte de la notion de protocole de communication et de la définition du format des messages échangés.
Ce premier cours introduit la notion de système embarqué en commençant par en donner une définition. Il les caractérise ensuite sur base de plusieurs critères : type d'application, de fonction visé, taille, fiabilité, efficacité. Il présente ensuite plusieurs aspects hardware (unité de calcul, architecture matérielle, composants clés) et software (niveau de programmation, processus de développement). Enfin, il conclut en discutant sur ce qu'est un ingénieur en systèmes embarqués.
Introduction à la partie technique de la formation Digitalent mise en place par l'équipe ECAM. Cette formation couvre l'impression 3D, la programmation et l'électronique embarquée.
Ce cours présente la programmation fonctionnelle et montre comment il est possible de programmer avec ce paradigme en utilisant Python. La première partie présente la notion d'objet de type fonction, les fonctions lambda, le type callable et les closures. La deuxième partie présente les décorateur et montre comment ajouter du comportement à une fonction à l'aide d'un décorateur. La troisième partie présente les itérateurs et les générateurs qui, grâce à l'instruction yield, génère les données à la demande.
Ce premier cours avancé sur Python concerne les deux structures de données avancées que sont les ensembles et les dictionnaires. Ces derniers sont notamment utilisés pour construire des bases de données orientées document.
Ce cours concerne le polymorphisme, c'est-à-dire la capacité pour une variable de prendre plusieurs types de donnée durant le temps de sa vie. Le cours présente aussi la notion de classe abstraite et d'interface qui est une classe abstraite pure.
Ce cours présente la notion d'héritage entre classes qui permet de construire une relation de type "is-a". On crée une sous-classe à partir d'une super-classe, pour en hériter une partie de ses membres. On peut ensuite y ajouter des membres spécifiques. Ce cours présente également la redéfinition de méthodes, et comment utiliser les modificateurs de visibilité des membres.
Ce cours présente comment définir de nouveaux objets en définissant des classes. Un objet est une instance d'une classe qui définit les variables d'instances (attributs) et méthodes (fonctionnalités) que les objets créés à partir de la classe auront.
Ce cours présente la notion de système d'exploitation et en particulier les Linux embarqués qui sont spécialement conçus pour des systèmes embarqués de haut niveau avec des processeurs à usage général (GPP) comme unité de calcul principale. Il explique ensuite comment Linux embarqué démarre, quelles sont les différentes phases et modalités de stockage du système d'exploitation. Enfin, il présente la BeagleBone Black, ses caractéristiques et comment la programmer. Le cours conclut en expliquant la notion de driver de périphérique et comment ils sont conçus sous Linux à l'aide de fichiers.
Ce cours introduit aux trois langages de programmation du Web que sont l'HTML, le CSS et le Javascript. L'HTML est un langage de balisage qui permet de décrire un document et sa structure. Le CSS est un langage qui permet de définir des règles de style à appliquer à un document. Enfin, Javascript est un langage permettant d'ajouter un aspect dynamique à une page web.
Cette présentation montre plusieurs outils gratuits qui peuvent être utilisés pour gérer plusieurs aspects de la gestion de projets, en particulier informatique, de manière collaborative. On y voit comment versioner son code avec Git, déployer son code avec Heroku, tester son code avec Travis, gérer et planifier son temps et ses tâches avec Trello, FreedCamp et Tom'splanner, comment communiquer avec Slack et comment rédiger sa documentation avec Read the Docs.
Ce cours introduit à la notion de type abstrait de données (TAD). On commence par y découvrir les principes de complexité temporelle et spatiale permettant d'analyser les performances d'une structure de données et d'algorithmes. Ensuite, le cours présente plusieurs TAD : la pile, la file, le deque et le vecteur. Enfin, il présente comment implémenter des TAD avec des structures chainées.
Ce cours est le premier en lien avec l'algorithmique présente les algorithmes et fonctions récursives ainsi que le type abstrait de données arbre. La première partie revient sur les notions de problème, algorithhme et spécification. La deuxième partie présente la récursion et de nombreux exemples. Enfin, la troisième partie présente le type abstrait de données arbre qui permet d'organiser des données de manière hiérarchique. Le cours se termine avec une introduction aux notions de backtracking et lookahead.
Ce cours présente comment réaliser des interfaces graphiques avec Python en utilisant la librairie Kivy. La première partie rappelle les principes de la programmation évènementielle puis présente la séparation interface/comportement à l'aide de fichiers KV et Python. La deuxième partie présente comment réaliser des dessins avec les composants Canvas. On y voit comment dessiner des formes, appliquer des transformations et on termine avec un exemple de composants déplaçables.
Cette conférence présente le framework Johnny-Five qui permet de programmer des cartes embarquées à l'aide d'un module Node.js. Après un tour rapide du JavaScript et de son fonctionnement, en particulier la programmation fonctionnelle et l'exécution pilotée par les évènements, la présentation décrit Node.js et aborde rapidement son fonctionnement. La troisième partie présente Johnny-Five et plusieurs exemples simples de contrôle d'une LED et de l'utilisation des entrées/sorties numériques et analogiques.
Auteurs : Simon Debaecke & Christophe Leemans
Support de la présentation donnée le 27 novembre 2012 dans le cadre du cours de développement mobile Android.
https://speakerdeck.com/skyless/le-guide-de-developpement-pour-android
Découverte du moteur de rendu du projet SpartanMicrosoft
Dans cette session, nous découvrirons l'ensemble des nouveautés du moteur de rendu du dernier navigateur de Microsoft. Vous l'avez peut-être déjà découvert lors de l'évènement du 21 janvier. Venez cette fois-ci découvrir ce qu'il y a sous le capot du point de vue du développeur. Ce sera pour nous l'occasion de vous parler des dernières technologies HTML5 comme ECMAScript 6, des dernières avancées côté WebGL ou bien encore du support de Web Audio. Pour finir, vous verrez également les progrès que nous avons effectué du côté la barre de développement.
Mise en place de l'ActionBarCompat dans vos projets Android.Mathias Seguy
Petite conférence sur la mise en place de l'ActionBarCompat dans votre application Android avec:
Mise en place de l'ActionBarCompat
Ajout de MenuItem
Mise en place d'une ActionView de recherche
Mise en place de l'ActionMode.
ToulouseAndroidUserGroup du 5 Juin 2014
Ce cours présente ce qu'est l'internet des objets (IoT), un réseau parallèle au web connectant entre eux des dispositifs physiques. Les différences majeures entre l'IoT et le web sont mises en avant, ainsi que les grands défis auxquels le monde de l'IoT est confronté. Le cours présente ensuite brièvement comment on peut gérer un système embarqué à distance, notamment pour la maintenance, le monitoring, le disaster recovery, notamment à l'aide d'un watchdog. Enfin, pour conclure, plusieurs architectures réseaux possibles sont présentées, pour inter-connecter des systèmes embarqués et les relier au web.
Ce cours présente la notion de système embarqué temps-réel et comment il est possible de gérer cela au niveau software avec un Linux embarqué. Plusieurs solutions sont présentées : OS temps-réel, linux préemptif et support hardware. Enfin, le cours présente le PRU-ICSS, dont est dotée la BeagleBone Black, une unité de calcul spécialisée pour les applications temps réel. Le cours présente comment programmer le PRU et notamment comment compiler un code à sa destination à l'aide d'un langage d'assemblage.
Ce cours présente les principaux moyens de communications que l'on peut déployer au sein d'un système embarqué. Après un rappel sur les différents types de communication (série/parallèle, synchrone/asynchrone, half-duplex/full-duplex), le cours présente le port série ainsi que l'implémentation UART. Vient ensuite le bus USB et les deux modes en hôte ou périphérique. Après cela, le cours présente les protocoles I2C et puis SPI. Enfin, il termine avec le simple bus 1-Wire. Tous ces différents moyens de communication sont disponibles sur la BeagleBone Black et le cours illustre comment les manipuler à l'aide du Linux embarqué.
Cette conférence présente LaTeX, un outil permettant de réaliser des documents de haute qualité typographique et professionnelle. Après avoir présenté quelques règles de typographie de la langue française, la présentation fait découvrir les bases de LaTeX et montre comment réaliser son premier document. Elle présente ensuite plusieurs constructions de base comme les listes, l'inclusion d'images et de tableaux, les mathématiques, les listings de code source. Enfin, elle termine avec des constructions plus avancées, comme la notion de figure et références croisées.
Ce second cours d'algorithmique présente des techniques utilisées en intelligence artificielle pour trouver une solution à un problème de recherche. La première partie définit un problème de recherche : état, action, arbre d'exécution, espace d'états, cout, objectif et formalisation. La deuxième partie présente plusieurs algorithmes de recherche : non informé (BFS, UCS, DFS, DLS, ID-DFS, BS), informé (BFS, A*) et avec adversaire (Minimax, Alpha-Beta Pruning). Enfin, la troisième partie présente deux librairies Python qui implémentent des algorithmes de recherche.
Ce cours introduit à l'intelligence artificielle. La première partie du cours présente et définit ce qu'est l'intelligence et décrit les notions d'agent rationnel et d'environnement et leurs propriétés. Ces deux concepts permettent d'offrir un cadre de réflexion sur l'intelligence. La fin de la première partie présente les neufs formes d'intelligence selon Howard Gardner. La seconde partie du cours présente et définit l'intelligence artificielle, initiée par Marvin Minsky et John McCarthy au MIT. Elle présente également le test de Turing, test permettant de déterminer si une machine peut penser. Cette partie se termine en présentant les six grands domaines de l'intelligence artificielle.
Ce cours présente les techniques que l'on peut utiliser pour effectuer des calculs parallèles avec une machine. La première partie introduit à la notion de parallélisme et de processus. Elle présente ensuite comment lancer et manipuler des processus avec les modules subprocess et multiprocessing. On y voit également comment communiquer entre processus avec des Queue et des Pipe. La deuxième partie présente les threads et leur utilisation avec le module threading. On y voit également comment créer un pool de workers/executors pour exécuter des jobs. Enfin, la dernière partie présente le framework dispy qui permet de facilement faire du calcul distribué et exploiter le parallélisme de données.
Ce premier cours introduit à plusieurs aspects liés au développement informatique. Le cours présente comment versioner son code avec le système Git et comment le déployer avec Heroku. Il présente ensuite comment débugguer avec le module pdb et comment profiler son code avec les modules timeit et profile. Enfin, le cours termine en présentant le concept de tests unitaires que l'on peut construire avec les modules doctest et unittest.
Ce cours présente le notion de qualité de code et quels sont les critères et pratiques à adopter pour produire du code de qualité. Il présente les erreurs de programmation les plus fréquentes auprès des apprentis programmeurs. La deuxième partie du cours présente la notion de convention de codage et en particulier le PEP 0008 qui décrit des conventions à adopter lorsqu'on programme en Python.
Ce cours présente la notion de qualité de code et comment il est possible de l'évaluer grâce à des métriques mesurables. Après avoir présenté plusieurs métriques standards, il se concentrer sur des aspects de qualité de code spécifique à l'orienté objet et présente les cinq concepts de l'orienté objet. La deuxième partie du cours présente plusieurs bonnes pratiques à avoir en programmation orientée objet, sur base d'exemples concrets.
Ce cours présente ce qu'est Internet et son fonctionnement. En partant de l'ordinateur personnel ou smartphone connectés en un réseau local, le cours remonte petit à petit vers le fournisseur d'accès et l'Internet complet. Le cours présente ensuite plusieurs protocoles qui assurent le bon fonctionnement d'Internet et des services qu'il permet d'offrir. Enfin, la dernière partie concerne l'internet des objets.
Ce cours concerne les arbres, structure de données organisant les données de manière hiérarchique dans de nœuds reliés entre eux par une relation parent-enfant. Le cours présente les arbres généraux et ensuite les arbres binaires, où chaque nœud possède 0 ou 2 enfants. Enfin, le cours termine en présentant des algorithmes de recherche et en particulier l'arbre binaire de recherche.
Ce cours présente le langage UML qui permet notamment de modéliser des logiciels programmés en orienté objet. Ce cours présente les diagrammes de classes qui permettent de décrire la structure d'un logiciel et les diagrammes d'activité qui permettent de décrire les aspects dynamiques de l'exécution.
Ce cours aborde la gestion d'erreurs en programmation, c'est-à-dire comment gérer les situations où une erreur se produit. Après avoir présenté le principe des spécifications et de la programmation défensive avec l'instruction assert, ce cours présente l'instruction try/except qui permet de capturer des erreurs. Enfin, le cours termine en présentant comment définir ses propres erreurs et les générer avec l'instruction raise.
2. Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons
Attribution – Pas d’Utilisation Commerciale – Pas de Modification 4.0 International.
3. Rappels
Classe
Définition d’une classe (variable d’instance et constructeur)
Définition d’un constructeur et instanciation d’un objet
Définition de méthode et appel
Programmation orientée objet
Représentation d’un objet avec __str__
Surcharge d’opérateur
Égalité des objets (==) et des identités (is)
Accesseur et mutateur
3
6. Graphical User Interface
Utilisation de la librairie graphique Tk pour les GUI
Importation de tkinter
Création d’une nouvelle fenêtre avec un objet Tk
Titre changé via la méthode title
1 from tkinter import *
2
3 window = Tk()
4 window.title(’LoL’)
5 window.mainloop ()
6
7. Widget
Interface graphique construite à partir de widgets
Composants tels que label, bouton, fenêtre, liste, case à cocher...
Widgets placés les uns dans les autres
Chaque composant a un composant parent
7
8. Label
Un label est une zone de texte non modifiable
On définit son texte avec le paramètre text
1 window = Tk()
2
3 text = Label(window , text=’Bonjour Clémence!’)
4 text.pack ()
5
6 window.mainloop ()
8
9. Bouton
Un bouton peut être cliqué pour déclencher une action
On définit son texte avec le paramètre text
1 window = Tk()
2 text = Label(window , text=’Bonjour Clémence!’)
3 text.pack ()
4
5 btn = Button(window , text=’Appeler ’)
6 btn.pack ()
7
8 window.mainloop ()
9
10. Frame
Une frame est une zone rectangulaire
Permet d’accueillir d’autres composants
1 window = Tk()
2
3 f = Frame(window , background=’red ’)
4 f.pack ()
5 text = Label(f, text=’Marchand joue avec son Arduino !’)
6 text.pack ()
7 ok = Button(f, text=’OK’)
8 ok.pack ()
9
10 window.mainloop ()
10
11. Notation compacte
Pas nécessaire de stocker une référence par widget
Sauf si on doit y faire référence ailleurs ou appeler des méthodes
Appel direct à pack après création du widget
1 window = Tk()
2
3 f = Frame(window , background=’red ’).pack ()
4
5 Label(f, text=’Marchand joue avec son Arduino !’).pack ()
6 Button(f, text=’OK’).pack ()
7
8 window.mainloop ()
11
12. Construction d’interface
Spécification du composant parent
Pour chaque nouveau composant créé
1 window = Tk()
2 Label(window , text=’Clémence aime les burgers.’).pack ()
3 f = Frame(window)
4
5 Button(f, text=’Oui’).pack(side=LEFT)
6 Button(f, text=’Non’).pack(side=LEFT)
7
8 f.pack ()
9 window.mainloop ()
12
13. Gestionnaire de mise en page
Trois manières de gérer la mise en page
pack permet du positionnement relatif
place permet de spécifier les coordonnées précises
grid permet de placer les composants en grille
1 window = Tk()
2 text = ’B’
3 for r in range (3):
4 for c in range (11):
5 Label(window , text=text).grid(row=r, column=c)
6 text = ’W’ if text == ’B’ else ’B’
7 window.mainloop ()
13
14. Placement précis
Positionnement avec des coordonnées précises
Attention, les composants peuvent se chevaucher
1 window = Tk()
2 window.geometry(’400 x200 ’)
3
4 Label(text=’Hello :-)’).place(x=70, y=40)
5 Button(text=’Click me!’).place(x=100 , y=50)
6
7 window.mainloop ()
14
15. Zone de texte
Un zone de texte permet à l’utilisateur de saisir un texte
On définit son contenu avec le paramètre text
1 window = Tk()
2 text = Label(window , text=’Dis moi ton nom , je te dis ton âge :’)
3 text.pack ()
4
5 Entry(window).pack ()
6
7 window.mainloop ()
15
16. Application graphique (1)
Encapsulation de l’interface graphique dans une classe
Création d’une classe représentant la Frame principale
1 class App(Frame):
2 def __init__(self , parent):
3 Frame.__init__(self , parent)
4 self.pack ()
5 self. createWidgets ()
6
7 def createWidgets (self):
8 text = Label(self , text=’Dis moi ton nom , je te dis ton âge
:’)
9 text.pack ()
10 Entry(self).pack ()
11
12 window = Tk()
13 app = App(window)
14 app.mainloop ()
16
18. Boucle d’évènement
Des évènements sont produits par l’utilisateur
Il faut associer les évènements à un gestionnaire
Initialisation
Réception
évènements
Terminaison
Fonctionnalités
du programme
mainloop()
18
19. Gestionnaire d’évènement
Associer une fonction à une action d’un composant
Via le paramètre command lors de la création
1 window = Tk()
2 Label(window , text="Please , forgive me! It’s not my fault!").pack ()
3 Button(window , text=’KILL!’, command=window.destroy).pack ()
4
5 window.mainloop ()
19
20. Application graphique (2)
Construire toute l’application graphique dans une même classe
Initialisation de la Frame
Création et placement des widgets
Association des gestionnaires d’évènements
1 window = Tk()
2 app = App(window)
3 window.title(’Guess my age ’)
4 app.mainloop ()
20
21. Initialisation de la Frame
Création de la Frame et initialisation
En appelant la méthode __init__ de Frame
Mise en page, puis ajout des widgets
En appelant pack puis createWidgets
1 class App(Frame):
2 def __init__(self , parent):
3 Frame.__init__(self , parent)
4 self.pack ()
5 self. createWidgets ()
6
7 def createWidgets (self):
8 # ...
9
10 # ...
21
22. Création du gestionnaire d’évènements
Ajout d’une méthode par gestionnaire d’évènements
La méthode a accès aux composants de la Frame
Le gestionnaire peut mettre à jour l’interface
Appels de méthodes des widgets
1 def computeage(self):
2 age = 2015 - int(self.__year.get())
3 self.__answer[’text ’] = ’Vous avez {} ans ’.format(age)
22
23. Création des composants
Création des composants et ajout dans la Frame
La référence self contient la Frame
1 def createWidgets (self):
2 # Création d’un panneau de contrôle
3 controls = Frame(self)
4 # Création du label
5 Label(controls , text=’Année de naissance ?’).pack(side=LEFT)
6 # Création de la zone de texte
7 self.__year = Entry(controls)
8 self.__year.pack(side=LEFT)
9 # Création du bouton
10 Button(controls , text=’Valider ’, command=self.computeage).pack
()
11 controls.pack ()
12 # Zone de réponse
13 self.__answer = Label(self , text=’...’)
14 self.__answer.pack ()
23
24. Canvas
Un canvas est un widget pour faire du dessin 2D
Des méthodes permettent de dessiner des objets graphiques
1 window = Tk()
2 c = Canvas(window , width =200 ,
height =200)
3 c.pack ()
4
5 c. create_line (0, 0, 200, 200,
fill=’red ’)
6
7 c. create_rectangle (50, 50,
100, 100, fill=’blue ’)
8
9 window.mainloop ()
24
25. Animation (1)
Création d’une animation par une succession d’images
Mettre à jour de manière régulière le canvas
1 class App(Frame):
2 def __init__(self , parent):
3 Frame.__init__(self , parent)
4 self.pack ()
5 self. createWidgets ()
6
7 def createWidgets (self):
8 self.__c = Canvas(self , width =200 , height =200)
9 self.__c.pack ()
10 self.__c.create_line (0, 0, 200, 200, fill=’red ’)
11 self.__rect = self.__c. create_rectangle (0, 0, 50, 50, fill=
’blue ’)
12 Button(text=’Move ’, command=self.move).pack ()
13
14 def move(self):
15 self.__c.move(self.__rect , 10, 10)
25