Types de données en Python - LMPT

Types de données en Python
– Integer : n=10
– Float : x=0.27; y=3e-28; z=3/5+x*y
– String : msg=’blabla’; rep=’re-’ ; chaine=msg+rep; chaine=2*msg; print(len(msg));
print(msg[2])
– List : liste=[’lundi’, ’mardi’, ’mercredi’]
Utilisation des listes : print(liste[2]); del(liste[0]); liste.append(’jeudi’); print(len(liste))
liste1+liste2; liste[3]=liste[3]+liste[4]+’hello’.
Interaction avec l’utilisateur : rep=input("Entrez un répertoire:") qui renvoit une chaîne
de caractères (convertir si besoin en entier, float etc...)
Exercices :
1. Ecrivez un programme qui convertit les degrés Celsius en degré Farenheit (T F = 9 5 T C + 32).
2. Ecrivez un programme qui calcule les intérêts cumulés pendant n années d’un capital de
départ C placé au taux d’intérêt r
3. Ecrivez un programme qui détermine le nombre de caractères a dans une chaîne entreé par
l’utilisateur.
4. Ecrivez un programme qui détermine si une chaîne est un palindrome.
5. A partir de deux listes L1 et L2 de même taille, écrivez un programme qui crée une liste L3
alternant les éléments de L1 et L2.
6. Ecrivez un programme qui recherche le plus grand élément d’une liste donnée.

Fonctions et modules
Fonction : retourne une donnée (quelque soit le type)
Procédure : ne retourne rien mais fait quelque chose
– Définition :
def ma_fonction ():
···
···
def autre_fonction ():
– Def avec paramètres : def ma_fonction (hauteur, nom, code)
– Initialisation : def ma_fonction (hauteur=3, nom=’echelle’, code=[])
– Appel : ma_fonction (3,’corbeau’)
– Appel avec étiquettes : ma_fonction (nom=’corbeau’, code=[2,3], hauteur=3)
– Pour une fonction : return, utilisation : a=ma_fonction(2,”,[3,5])
Par défaut les variables sont locales, sinon utiliser global.
Module : regroupement de fonctions (équivalent d’une librairie) voire plus (POO), mon_module.py
(ne pas reprendre un nom déjà existant).
Importer un module : import mon_module
Attention, les définitions de fonction doivent précéder le corps du programme, de même qu’une
fonction servant à une autre.
Exercices :
1. Ecrire une fonction qui compte le nombre de mots dans une phrase
2. Ecrire une fonction changeCar(ch, ca1, ca2, debut, fin) qui remplace dans la chaîne
ch tous les caractères ca1 par les caractères ca2 à partir de l’indice debut, jusqu’à l’indice fin.
Si début et fin sont omis, le traitement concerne toute la chaine.
3. Ecrire une fonction chercheMax(liste, debut, fin) qui cherche dans la liste liste,
l’élément maximum (au sens mathématique). La recherche doit s’effectuer entre les rangs d’indice
debut et fin. Si début et fin sont omis, le traitement concerne toute la liste.
4. Ecrire une fonction erathostene(n) qui renvoit tous les nombres premiers compris entre
1 et n en utilisant le crible d’Erathostène.
5. Ecrire une fonction mobius(n) qui calcule la fonction de mobius de n.
6. Mettre toutes ces fonctions dans un module appelé essai_module.py et l’importer pour
faire un programme demandant à un utilisateur d’entrer un entier, donant en retour la fonction
de mobius et les nombres premiers entre 1 et l’entier.

Chaines, Listes, Tuples, Dictionnaires
1. Chaines de Caractères
– ch[1:3] donne ’lab’
– ch[-4] donne ’a’
– comparaison : ch1, ch2 = ’bla’ , ’def’
alors on peut tester if ch1 < ch2 :
– parcourir une chaine : for i in ch :
– test d’appartenance : if i in ch :
– split(car) : chaine vers liste en découpant au caractère car
– join(liste) : liste vers chaine "–-".join(liste)
– replace(c1,c2) : remplace le caractère c1 par c2
– index(car) : revoit la première occurence de car
– format(tuple) : formate la chaine en remplaçant les {}
2. Listes
– test d’appartenance : if i in liste :
– parcourrir la liste : for i in liste :
– Attention : liste2=liste fait un nouveau pointeur vers la même liste
– Slicing : liste[2:2]=["blabla", "re-blabla"], liste[2:5]=[]
3. Tuples
Entre chaine de caractère et liste : ordonné mais pas modifiable (moins gourmand).
tup=’a’,’b’,’c’,’4’
print(tup)
(’a’,’b’,’c’,’4’)
4. Dictionnaires
Type composite non ordonné contrairement aux autres. Donc on utilise une clef et le dictionnaire
est constitué de paires (clef,valeur).
– initialisation : dico={}
– dico[’pommes’]=’3’
– la clef peut être plus générale, par exemple des coordonnées de point sous forme de tuple :
dico(3,4)=’touché’
– si la clef n’est pas définie, l’appel renvoit une erreur. On a donc la méthode suivante : dico.get(clef,
’pas définini’).
– print(dico.keys())
– print(dico.values())
– print(dico.items())
– del(clef) supprime l’entrée associée
– parcourrir le dictionnaire : for clef in dico :
– test d’appartenance : if clef in dico :
On peut controller le flux à l’aide d’un dictionnaire (très utile) :
possibilites = {’a’:fonction_A , ’b’:fonction_B, ’c’:fonction_C}
possibilites(choix)()

-> exécute la fonction correspondant au choix, c’est l’équivalent de case/switch.
Mieux :
possibilites.get(choix, fonction_par_defaut)()
Exercice :
Créer un script qui créée un mini-système de base de données fonctionnant à l’aide d’un dictionnaire
dans lequel on mémorise les noms d’une série de copains, leur age et leur taille. Le
script doit comporter deux fonctions : la première pour le remplissage du dictionnaire et la
seconde pour sa consultation. Dans la fonction de remplissage, on utilisera une boucle pour
accepter les données entrées par l’utilisateur.
Dans le dictionnaire, le nom de l’utilisateur servira de clef, et les valeurs seront constituées de
tuple de la forme (age,taille) où l’age est un entier en années et la taille un réel en mètres.
La fonction de consultation comportera elle aussi une boucle, dans laquelle l’utilisateur pourra
fournir un nom quelconque pour obtenir en retour le couple (age,taille) correspondant. Le
résultat de la requête devra être une ligne de texte bien formatée, par exemple :
«Nom : Jean Dupont - âge : 15 ans - taille : 1.74 m »

Travailler avec des fichiers
1. Se placer dans le bon répertoire :
from os import chdir, getcwd
print(getcwd())
chdir("/home/toto/mon_rep")
print(getcwd())
2. Ecrire dans un fichier séquentiellement :
obFichier = open(’mon_fichier’, ’a’)
obFichier.write(’Hello you !’)
obFichier.write(’How are you ?’)
obFichier.close()
3. Lire un un fichier séquentiellement :
obFichier = open(’mon_fichier’, ’r’)
t=obFichier.read()
print(t)
obFichier.close()
’a’ :append ; ’w’ :write ; ’r’ :read
read(nb) -> nb entier donne le nombre de caractères à lire.
4. Lire ligne à ligne avec une boucle infinie :
fs = open(’source.txt’, ’r’)
fd = open(’destination.txt’, ’w’)
While 1:
ligne=fs.readline()
if ligne=="":
break
if ligne[0]!=’#’:
fd.write(ligne)
fs.close()
fd.close()
Attention à écrire des chaines de caractères (convertir si besoin en str). Sinon, pour conserver
le type, utiliser le module pickle.
5. gestion des erreurs au cas où il ne soit pas possible d’ouvrir le fichier :
fichier=input(’Entrez un nom de fichier’)
try:
f = open(fichier, ’r’)
f.close()
except:
print(’fichier introuvable’)
Exercice : reprendre des codes en C sur les fichiers et les transcrires en python

La programmation orientée objet
Il s’agit d’un paradigme de programmation, non obligatoire en python, mais très utile pour
faire du code à la fois sûr et bien conçu.
1. Une classe va regrouper des objets possédant des caractéristiques souvent similaires. Par
exemple, la classe des moyens de locomotions.
L’emploi de classes va permettre d’encapsuler un certain nombre de variables et de méthodes,
ce qui donnera une programmation mieux structurée et plus sécurisée (on risque moins de
modifier des données qui ne devraient pas l’être).
Au sein d’une classe, certaines variables et méthodes peuvent être publiques (accessibles de
l’extéreur) et d’autres privées (accessibles seulement de façon interne, dans la classe).
2. L’héritage permet de construire des sous-classes ou classes-enfant possédant les fonctionalités
de la classe parent, mais en définissant aussi ses propres fonctionalités. Par exemple, on
peut construire la classe-enfant "voitures" à partir de la classe-parente "moyens de locomotions".
Un autre mécanisme existe : le polymorphisme qui permet de modifier les comportement des
objets d’une classe selon le contexte.
3. Les objets sont des membres d’une classe. Un objet regroupe deux choses : des attributs et
des méthodes. Lorsqu’on créé un représentant d’une classe, on dit qu’on instancie un objet.
Pour cela, on utilise une méthode spécifique de la classe, appelée méthode constructeur.
4. Les attributs sont des données associées à un objet. Par exemple : si on considère un objet
de la classe "voiture", la couleur est un attribut de cet objet. Une méthode est une fonction ou
procédure, agissant sur les attributs de l’objet. Méthodes et attributs sont eux-mêmes encapsulés
dans l’objet.

En pratique :
class Voiture(object):
# definition des attributs et méthodes à venir
utilisation :
simca = voiture() # instanciation d’un objet
simca.couleur = rouge # attribut couleur
Exemple d’une fonction qui instancie un objet voiture et lui affecte une couleur :
def voiture_coloree(couleur):
v = Voiture()
v.couleur = couleur
return v
simca = voiture(’rouge’)
peugeot = voiture(’verte’)
print(simca.couleur, peugeot.couleur)
On pourrait coder une couleur par défaut dans la classe, c’est ce que nous ferons plus tard,
ainsi que définir des méthodes. Affecter une couleur comme nous l’avons fait n’est pas la
meilleure façon de faire mais c’est suffisant pour le moment.
Les objets peuvent eux-même comporter des objets en tant qu’attributs. Par exemple, l’objet
"voiture" peut comporter l’objet "siège" qui aura lui même des attributs de largeur, longeur,
matière etc...
simca.siege.largeur = 70
Cette notation à l’aide de point (.) est fondamentale, on l’appelle qualification de nom hierarchisée,
du plus gros contenant vers le plus petit, et enfin les attributs finaux (ou les méthodes).
Définition d’une méthode constructeur et d’une méthode quelconque dans une classe (self
représente l’objet instancié) :

class Time(object):
# classe d’objets temporels
def __init__(self): # méthode constructeur
self.heure = 12
self.minute = 0
self.seconde = 0
def affiche_heure(t): # une méthode
print("{}:{}:{}".format(t.heure, t.minute, t.seconde))
Utilisation : objet.méthode()
temp_start = Time()
temp_start.affiche_heure()
Instanciation avec paramètres :
def __init__(self, hh = 12, mm = 0, ss = 0):
self.heure = hh
self.minute = mm
self.seconde = ss
pause = Time(hh = 10)
pause.affiche_heure()
# méthode constructeur
Exercices :
1. Définir une classe CompteBancaire() qui permet d’instancier des objets tels que compte1,
compte2, ... Le constructeur initialisera deux attributs d’instance nom et solde avec les valeurs
par défaut ’duschmol’ et 1000. Trois méthodes doivent être aussi définies : depot(somme)
qui permet d’ajouter de l’argent au compte ; retrait(somme) qui permet de retirer de l’argent
(pas de découvert autorisé !) ; et affiche() qui renvoit le solde du compte.
2. Définir une classe Satellite() qui permet d’instancier des objets représentant des satellites
lancés autour de la terre. Le constructeur initialise deux attributs d’instance par défaut
comme suit : masse=100, vitesse=0. Lorsqu’on instancie un satellite, on peut choisir son
nom, sa masse et sa vitesse. Définir ensuite une méthode impulsion(force, duree) qui permet
de faire varier la vitesse du satellite (variation de vitesse = force * temps / masse) ; une méthode
affiche_vitesse() qui affiche le nom du satellite et sa vitesse courante ; une méthode
energie() qui renvoit l’énergie cinétique courante du satellite.

Un zeste de cryptographie
1. Le chiffre de Caesar
Ce chiffrement consiste à décaler les lettres d’un pas constant. Par exemple, si on choisit un
décalage de 4, on va alors substituer la lettre A par E, B par F , C par G etc... (et on boucle, par
exemple Z est remplacé par D).
Ce chiffrement est un chiffrement monoalphabétique par subsitution.
2. Cryptanalyse du chiffre de Caesar
Le chiffre de Caesar est suceptible d’être cassé par l’analyse de fréquence, comme tout chiffrement
monoalphabétique : dans la langue française, la lettre E est la plus fréquente, puis vient
la lettre A etc... donc en repérant les occurences, on peut en déduire quelle est le substitut pour
E, A ... Evidemment, plus le texte chiffré est long, plus fiable est la cryptanalyse.
3. Chiffre de Vigenère
Il s’agit d’un chiffrement polyalphabétique : le chiffrement change à chaque nouvelle lettre,
selon une clef définie et qui doit être connue de l’éméteur et du récépteur pour déchiffrer le
message. Si par exemple la clef est "permanent", alors les décalages successifs sont les suivant :
16,5,18,13,1,14,5,14,19 puis on reprend le décalage à 16,5 etc...
Ce chiffrement est beaucoup plus difficile à analyser. Il faut d’abord tenter de repérer la longueur
l de la clef de chiffrement en repérant des occurences, puis travailler comme pour le
chiffrement de Caesar sur chaque morceau de longueur l.
Exercices – faire des scripts python qui effectuent le chiffrement et déchiffrement de Caesar
et de Vigenère (en fournissant la clef à chaque fois) ; puis un script faisant la cryptanalyse du
chiffrement de Caesar par analyse de fréquences.

Programmation réseau en python
On est sur le principe client /serveur : le client se connecte sur un serveur déterminé par son
nom ou son adresse IP, sur un port précisé. L’objet fondamental est un socket, qui est une
brique logicielle se mettant en écoute derrière un port, et pouvant également transmettre des
données sur ce port.
Coté client :
On débute par instancier un objet de type socket et le connecter sur le serveur :
# client basique
import socket
HOST = ’10.68.5.171’
PORT = 5000
clientsock = socket.socket(socket.AF_ INET, socket.SOCK_ STREAM)
clientsock.connect((HOST,PORT))
A partir de là, le client peut soit recevoir, soit émettre des données à travers le socket clientsock.
Mais pour cela, il faut avant avoir mis, coté serveur, un soscket en écoute, sur le port adapté et
on accepte les connexions entrantes.
Coté serveur :
# serveur basique
import socket
HOST = ”
PORT = 5000
serversock = socket.socket(socket.AF_ INET, socket.SOCK_ STREAM)
serversock.bind((HOST,PORT))
serversock.listen(1)
(clientsock, address) = serversock.accept()
Le tuple (clientsock, address) contient d’une part un objet servant de référence vers le socket
client qui s’est connecté au serveur, et d’autre part un tableau adress contenant l’adresse
IP et le port utilisé par le client pour se connecter.
Coté serveur aussi, on peut envoyer ou récupérer des données transitant par le socket serversock.
Une fois la tranmission faite, il ne faut pas oublier de fermer les sockets, sans quoi le port utilisé
ne sera plus disponible. On réalise cela à l’aide de la méthode close() :
# cote client :
clientsock.close()
# cote serveur :
serversock.close()

Si le programme s’est interrompu de façon subite avant d’avoir correctement fermé le socket,
on peut supprimer l’application en écoute sur le port concerné grace à la commande shell
lsof -i qui donne le PID du processus actif sur le port.
Envoi et Réception de données
On utilise deux méthodes assez simples à comprendre : send(), recv() mais il faut penser
à encoder et décoder en mode UTF-8 (par exemple) dans le cas d’un envoi de texte, car la
transmission de données se fait en type byte par défaut.
Coté client, on peut donc compléter le code par exemple par :
text = input(’Send a text : ’)
clientsock.send(text.encode(’utf-8’))
clientsock.close()
et coté serveur :
print(clientsock.recv(1024).decode(’utf-8’))
serversock.close()
Exercice 1 : Mettre en place un protocole de sécurisation de la connexion en demandant au
client de s’authentifier lorsqu’il se connecte sur le serveur.
Exercice 2 : Mettre en place un système de messagerie entre un client et un serveur sur la même
machine (on utilisera deux fenêtres), puis entre deux machines différentes.

Controle Continu n o 2
Le principe du code Morse est de substituer chaque lettre par une suite de signaux courts
(représentés par un point « . ») ou longs (représentés par un trait « _ ») selon le modèle suivant :
On ne tient pas compte ici ni de la ponctuation ni des chiffres (qui ont une codification Morse
également). Un trait équivaut en longueur à trois points ; entre deux lettres, on laisse l’équivalent
de trois points blancs ; entre deux mots on laisse l’équivalent de sept points blancs.
Ainsi, la phrase « le petit chat » se traduira en Morse :
L E P E T I T ···
. _ . . (3B) . (7B) ._ _ . (3B) . (3B) _ (3B) . . (3B) _
où (3B) représente une série de trois blancs et (7B) une série de sept blancs. On choisit donc
ici de représenter ce code sous forme d’une liste consituée de chaines de caractères ainsi :
[ ._.. ,(3B), . ,(7B), .__. ,(3B), . ,(3B), _ ,(3B), .. ,(3B), _ ]

Vous devez réaliser un module morse.py implémentant les fonctions suivantes :
a) string_to_morse(chaine) : prend en entrée une chaine de type string et renvoit une
liste constituée du code morse correspondant.
b) morse_to_string(liste) : qui fait l’inverse, prenant en entrée une liste et donnant en
retour une chaine de caractères.
c) kbd_to_morse() : une procédure qui se met en écoute au clavier et transcris à l’écran directement
en morse les caractères entrés au clavier (bien entendu on ne tient pas compte
des accents, majuscules, chiffres et ponctuation, sauf les espaces entre les mots). La procédure
comportera une boucle qui se terminera si l’utilisateur entre le caractère «*».
Indication : pour la procédure c), voici un bout de code à examiner et utiliser :
import curses # import de la librairie curses
stdscr = curses.initscr() # initialisation du terminal curses
curses.cbreak() # mode où l’entrée des caractères ne nécessite pas de CR
curses.noecho() # n’envoit pas les charactères à l’écran lors d’une saisie
while 1:
c = chr(stdscr.getch()) # récupère un caractère entré au clavier
stdscr.addstr(c+’|’) # envoit le caractère en console suivi de ’|’
stdscr.refresh() # raffraichit l’affichage
curses.endwin()
# ferme le terminal curses

Utilisation du module tk
Classes :
Tk, Label, Button, Entry, Canevas, Frame etc...
Méthodes :
pack(), mainloop(), quit(), destroy(), bind()
Premier exemple : calculatrice graphique
from tkinter import *
def evaluer(event):
chaine.configure(text = "Résultat = " + str(eval(entree.get())))
fenetre = Tk()
entree = Entry(fenetre)
entree.bind("", evaluer)
chaine = Label(fenetre)
entree.pack()
chaine.pack()
fenetre.mainloop()

Deuxième exemple :
from tkinter import *
def avance(gd,hb):
global x1,y1
x1, y1 = x1 + gd, y1 + hb
can1.coords(oval1, x1, y1, x1+30, y1+30)
def depl_gauche():
avance(-10,0)
def depl_droite():
avance(10,0)
def depl_haut():
avance(0,10)
def depl_bas():
avance(0,-10)
#––––- main –––––
x1, y1 = 10, 10
fen1 = Tk()
fen1.title("Exercice d’animation")
can1 = Canvas(fen1, bg = ’dark grey’, height = 300, width = 300)
oval1 = can1.create_oval(x1,y1,x1+30,y1+30,width=2,fill=’red’)
can1.pack(side=LEFT)
Button(fen1, text=’Quitter’, command=fen1.quit).pack(side=BOTTOM)
Button(fen1, text=’Gauche’, command=depl_gauche).pack()
Button(fen1, text=’Droite’, command=depl_droite).pack()
Button(fen1, text=’Haut’, command=depl_haut).pack()
Button(fen1, text=’Bas’, command=depl_bas).pack()
fen1.mainloop()

Troisième exemple
from tkinter import *
def cercle(can, x, y, r):
can.create_oval(x-r,y-r,x+r,y+r)
class Application(Tk):
def __init__(self):
Tk.__init__(self)
self.can=Canvas(self, width=475, height=130, bg=’white’)
self.can.pack(side=TOP, padx=5, pady=5)
Button(self, text="Train", command=self.dessine).pack(side=LEFT)
Button(self, text="Hello", command=self.coucou).pack(side=LEFT)
def dessine(self):
self.w1=Wagon(self.can, 10, 30)
self.w2=Wagon(self.can, 130, 30)
self.w3=Wagon(self.can, 250, 30)
self.w4=Wagon(self.can, 370, 30)
def coucou(self):
self.w1.perso(3)
self.w1.perso(1)
self.w1.perso(2)
self.w1.perso(1)
class Wagon(object):
def __init__(self, canev, x,y):
self.canev, self.x, self.y = canev, x, y
canev.create_rectangle(x,y,x+95,y+60)
for xf in range(x+5,x+90,30):
canev.create_rectangle(xf,y+5,xf+25,y+40)
cercle(canev, x+18, y+73, 12)
cercle(canev, x+77, y+73, 12)
def perso(self, fen):
xf = self.x + fen*30 - 12
yf = self.y + 25
cercle(self.canev, xf, yf, 10)
cercle(self.canev, xf-5, yf-3, 2)
cercle(self.canev, xf+5, yf-3, 2)
cercle(self.canev, xf, yf+5, 3)
app = Application()
app.mainloop()

Utilisation de threads en python
On utilise le module threading qui permet de générer des threads différents, ce qui permet de
faire des programmes multi-tâche. Voici un exemple basique d’utilisation :
import threading
def affiche(nb, nom = ”):
for i in range(nb): print nom, i
a = threading.Thread(None, affiche, None, (200,), {’nom’:’thread a’})
b = threading.Thread(None, affiche, None, (200,), {’nom’:’thread b’})
a.start() b.start()
L’objet Thread est généré sous la façon suivante : Thread(None, fonction, nom, args,
dico). Ici, fonction représente l’appel à une fonction précédement définie et on lui passe
les arguments args (sous forme de liste) et dico (dictionnaire associant paramètre/valeur).
On invoque ensuite la méthode start() qui lance le thread en lui-même. En réalité cette méthode
invoque elle-même la méthode run, mais dans un thread lui-même différent du cours
d’exécution actuel. La méthode run peut être surchargée, lorsqu’on crée une sous-classe de
Thread().
Autre exemple où l’on voit les deux threads en exécution :
import threading, time
def timer():
global tps
while 1:
time.sleep(1)
tps=tps+1
print(tps)
def inp():
while 1:
ch=input(’Entrez un mot’)
print(’le mot est: ’+ch)
tps = 0
a = threading.Thread(None, timer, None, (), )
b = threading.Thread(None, inp, None, (), )
a.start()
b.start()

Controle Continu n o 3
Le but du projet est de créer un « pipotron », un générateur d’excuses aléatoires. Pour cela, une
excuse est une phrase constituée de sujet + verbe + autre chose.
Par exemple : « ma grand-mère était malade », « le bus avait du retard », « le réveil n’a pas
sonné » etc...
Vous devez :
– construire une interface graphique contenant : trois zones de texte avec un bouton en dessous
de chaque zone : "sujet", "verbe", "complément" ; et deux boutons supplémentaires à
part : "pipotron" et quitter". Le bouton "quitter" sert bien à quoi l’on pense.
– un click sur le bouton "sujet" choisit un sujet au hasard dans une liste de sujets, un click sur
le bouton "verbe" choisit un verbe au hasard dans la liste des verbes et enfin un click sur
"complément" choisit un complément de phrase au hasard dans la liste correspondante.
– lors de chaque click, la zone de texte correspondante est raffraichie, faisant apparaitre une
nouvelle excuse. 1
– un click sur "pipotron" ajoute la phrase complète obtenue à un fichier sur le disque « pipotron.txt
», constituant ainsi une base d’excuses.
– dans l’idéal, la liste des sujets, des verbes et des compléments devrait être constituée de trois
fichiers mais on se contentera de listes crées dans le script lui-même.
1. la phrase obtenue n’a pas forcément un sens : « ma grand-mère n’a pas sonné » :)

Utilisation de threads en python — suite
On utilise l’héritage pour redefinir des threads. Le script précédent peut être donc réécrit ainsi :
import threading, time
class ThreadTimer(threading.Thread):
def __init__(self, depart):
threading.Thread.__init__(self)
self.tps = depart
def run(self):
while 1:
time.sleep(1)
self.tps += 1
print(self.tps)
class ThreadInput(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
while 1:
ch=input(’Entrez un mot ("fin" pour terminer)’)
print(’le mot est: ’+ch)
if ch == ’fin’:
Th_Timer._stop()
break
Th_Timer = ThreadTimer(3) Th_Input = ThreadInput()
Th_Timer.start()
Th_Input.start()
Exercices :
1. Ecrire un système client de messagerie en utilisant deux threads : un pour l’émission et
un pour la récéption de sorte à pouvoir faire les deux de façon simultanée.
2. Ecrire un serveur en utilisant là aussi plusieurs threads : chaque nouvelle connection
d’un client devra générer un thread. Le serveur en tant que tel ne fait que retransmettre
aux clients ce qu’ils échangent entre eux.
3. améliorer le serveur pour qu’il écrive qui est en train de parler ; améliorer le client pour
créer une interface graphique et éventuellement, gérer les smileys.