TD1 : Découverte de Python et des objets

Installation de Python (bâtiment Nautibus)

Si vous ne trouvez pas python 2.5 sur votre machine, il va falloir l'installer. Pour cela, téléchargez l'installeur python 2.5, lancez-le et suivez les instructions.

Découverte de l'environnement Python

Lancez IDLE, qui est un shell lié à l'interpréteur, et qui dispose d'un éditeur.

Dans l'interpéteur, testez quelques appels et fonctions :

• Définissez deux variables entières, deux variables réelles, deux chaînes de caractères
• Affichez-les en tapant le nom de la variable ou en utilisant print
• Faites quelques calculs sur ces variables (addition, multiplication) et opérations de manipulation de chaines (concaténation, affichages, extractions, etc.)

Définition de fonctions/procédures dans l'interpréteur

• Tapez dans l'interpréteur la fonction fibonacci du cours, testez-là avec plusieurs paramètres, ajoutez-y des affichages et testez-la à nouveau.
• Définissez une fonction qui prend une liste d'entiers en entrée et rend une liste en sortie ne contenant que les membres pairs. Testez-la.

  def pair(liste_entree):
  	liste_sortie = []
  	for element in liste_entree:
  		if element % 2 == 0 :
  			liste_sortie.append(element)
  	return liste_sortie
  		

Manipulation d'objets en python, modules

Températures

• Enregistrez dans votre dossier python le fichier suivant temp.py
• Ce fichier définit une classe Temperature. Ouvrez-le dans IDLE, et étudiez-en le code. Combien y-a-t'il de méthodes ? Quelles sont les méthodes qui modifient l'état des instances ?
  • 7 méthodes dont 1 constructeur, et 3 qui modifient l'état des instances
• Dans l'interpréteur, créez plusieurs instances de la classe Temperature, puis mettez-les dans une liste. Créez une fonction d'affichage des températures en °C et en °K.
• Créez un programme qui affiche une table de conversion C / K entre -20 et +100 °C.

def conversion(min, max) : 
	# ici il faudrait mettre un test pour vérifier que min < max
	liste = []
	for t in range(min, max, 5):
		liste.append(Temperature(t+273.16) # on remplit la liste d'objets. t est un entier
	for t in liste :
		print t.inC(), " en °C donne ", t.inK(), " en °K" # on écrit les conversion. t est ici un objet instance de Temperature

• Lancez l'interpréteur, chargez-y les fonctions que vous avez définies dans temp.py (pour cela, importez toutes les fonctions définies avec la commande import : import temp). Testez les différentes fonctions (vous pouvez les appeler en es préfixant du module chargé (temp.fonction).
  • en effet, si vous faites import temp, vous vous donnez le droit d'accéder aux élément du module temp, auxquels vous pourrez accéder en les préfixant du nom du module, par exemple temp.Temperature est la classe Temperature du module temp, temp.conversion est la fonction conversion du module temp.
  • pour pouvoir utiliser directement Temperature et conversion, il faut importer directement les élément de temp : from temp import *
• Créez un programme traducteur.py qui demande à l'utilisateur une température en C, et la lui traduit en K (utiliser la commande input pour récupérer des nombres du clavier, il faudra également importer le module défini dans temp.py).

  from temp import Temperature

  def traducteur():
     t = Temperature(100) # on crée un objet pour nos calculs
     while 1:
     	# on récupère une chaîne
     	tc = raw_input("Entrez une température en °C (q pour quitter) : ") 
     	if tc=='q': # si elle vaut q
     		break; # on quitte le while
     	t.setC(float(tc)) # sinon on met la température dans l'objet
     	# remarque : on a transformé la chaine en reel avec float()
     	print "Ce qui nous donne ", t.inK(), "°K" # affichage et calcul. 
     print "Au revoir"

Tortues

• Créez un nouveau fichier python. Au début de votre nouveau programme, importez le module turtle, dont vous trouverez la documentation sur http://docs.python.org/lib/module-turtle.html
  • Remarque : pour importer toutes les classes de turtle, faire from turtle import *
• Créez un objet Pen, puis faites appeler les différentes méthodes décrites dans la documentation pour les tester

import turtle 		# ou : from turtle import *
p = turtle.Pen()	# ou : p = Pen()
p.forward(50)
p.right(90)
p.forward(100)

• Mettez en place une procédure etoile qui dessine une étoile fermée régulière en prenant comme paramètres une taille, un nombre de branches et un stylo (méthode astérisque : avancer de taille, reculer de taille, tourner de 360° / nombre de banches, recommencer nombre de branches fois).

def etoile(taille, nombre, tortue)
	angle = 260 / nombre	
	for i in range(nombre):
		forward(taille)
		backward(taille)
		right(angle)

Mettez en place une procédure spirales qui prend une liste de tortues comme paramètres, et leur fait dessiner des spirales (avancer de n pas, tourner d'un angle faible, avancer de m<n pas, tourner à nouveau, etc.).

def spirales(liste):
	dist = 40
	while dist > 0:
		for t in liste:
			t.forward(dist)
			t.right(15)
		dist = dist - 1

Mettez en place une procédure depart qui crée une liste de n tortues, placées aléatoirement sur la zone de dessin.

# on importe la fonction random du module random
# la fonction random() rend un réel entre 0 et 1
# la fonction randint(a,b) rend un entier entre a et b

from random import * 

# à remarquer  : on utilise une variable intermediaire nouvelle, qui permet de créer
# des tortues, qu'on "range" dans la liste des tortues, où elle seront accessibles en 
# tant qu'éléments de liste

def depart(n):
	i = 0
	l = [] 
	while i < n : 
		nouvelle = turtle.Pen()
		nouvelle.setx(randint(-1 * nouvelle.window_width()/2 , nouvelle.window_width()/2) )
		nouvelle.sety(randint(-1 * nouvelle.window_height()/2 , nouvelle.window_height()/2) )
		l.append(nouvelle)
		i = i + 1
	return l 

Mettez en place une fonction distance qui prend une valeur d et deux tortues en entrée, et rend vrai si celles-ci sont à moins de d de distance (on peut utiliser la fonction hypot du module math).

# import du module math, qui contient des fonctions mathématiques telles que sqrt (racine carrée), pow (puissance)

# position() renvoie une paire (x,y). Cf. la doc du module turtle
# le reste est une application du théorème de pythagore (niveau collège)

def distance (t1, t2) :
	x1,y1 = t1.position()
	x2,y2 = t2.position()
	return math.sqrt( math.pow( (x2-x1) , 2) + math.pow( (y2-y1), 2 ) ) 

Modifiez spirales en spirales2 telle que les tortues s'arrêtent quand elles sont trop proches.

Finalement un peu trop compliqué, on va négliger cette question !