Snt : Les données

MENU DE CE MODULE

Nous voici arrivé au module 5 de notre cours. Ce module contient deux parties importantes à la fois au niveau de leur contenu et au niveau de leur volume.

Nous allons parler de structures de données plus complexes que ce que nous avons vu jusqu’à présent. En clair, nous allons analyser de façon fouillée les trois types de données chaînes de caractères, tuples et listes.

Mais dans ce module, nous allons aussi réaliser le projet associé au cours. Ce projet, dont nous avons déjà parlé et pour lequel nous avons déjà encodé des bribes, demande d’écrire un code plus volumineux que les exercices accompagnés ou autonomes UpyLaB que vous avez déjà réalisés. Grosso modo, nous estimons qu’un tiers du temps consacré à ce module le sera pour la réalisation de votre projet, même si cela peut être fort variable pour chacun de vous, en fonction de votre facilité à réaliser un projet plus important que d’habitude. C’est pour ces raisons que la période de temps dédiée au module 5 est deux fois plus grande que pour les modules 2 à 4 et 6.

Indication

Si vous travaillez séquentiellement sur la matière, la première section ainsi que le projet devraient idéalement être terminés avant le tiers du temps imparti.

LES CHAÎNES DE CARACTÈRES

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

LES TUPLES ET LES LISTES

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

TESTS ÉLÉMENTAIRES ET INSTRUCTION FOR

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

CODIFICATION UTILISÉE PAR PYTHON POUR LES TEXTES

Dans les vidéos que nous venons de présenter, nous avons parlé de comparaison entre caractères. Mais, par exemple, quel est le résultat du code ?

c1 = '#'
c2 = '€'
if c1 < c2:
    print("Ce code est juste un exemple")

Pour le savoir nous devons nous pencher sur la codification des caractères en Python.

En fait, Python encode ces caractères grâce à la codification UTF-8. Regardons ce que cela veut dire.

D’après l’entrée UTF-8 de wikipedia : « UTF-8 (abréviation de l’anglais Universal Character Set Transformation Format 1 - 8 bits) est un codage de caractères informatiques conçu pour coder l’ensemble des caractères du « répertoire universel de caractères codés » … Il s’agit du codage le plus utilisé dans les systèmes GNU, Linux et compatibles pour gérer le plus simplement possible des textes et leurs traductions dans tous les systèmes d’écritures et tous les alphabets du monde. »

En clair, à chaque caractère est attribué, par la norme UTF-8, un numéro qui lui est propre et que Python utilise pour le stocker mais aussi pour le comparer aux autres caractères. UTF-8 essaye de donner un numéro à tous les caractères de tous les alphabets connus.

ORD(C)

En Python, la fonction prédéfinie ord(x) donne le numéro dans le classement UTF-8 du caractère x.

Ainsi '#' < '€' est vrai car ord('#') vaut 35 et ord('€') vaut 8364. Une des seules choses que vous devez retenir est que :

les caractères qui correspondent aux chiffres '0' à '9' ont des numéros contigus (ord('0') vaut 48, ord('1') vaut 49, …) ;
idem pour les lettres minuscules 'a' .. 'z' (ord('a') vaut 97, ord('b') vaut 98, …) ; et pour les lettres majuscules 'A'.. 'Z' (ord('A') vaut 65, …).

Ainsi ayant un caractère dans la variable c, le test Python

'a' <= c and c <= 'z'

teste bien si c est une lettre de l’alphabet en minuscule. On peut faire la même chose avec les caractères majuscules ou les caractères qui correspondent à des chiffres. Attention à ne pas mélanger la valeur 0 et le caractère '0' dont la codification UTF-8 (ord('0')) vaut 48.

CHR(V)

La fonction prédéfinie chr(v) est l’inverse de ord( ) : chr(v) reçoit en paramètre un nombre entier positif v, et renvoie la caractère UTF-8 correspondant. Par exemple chr(65) renvoie 'A'.

TEMPÊTE OU CYCLONE

Même si nous n’avons pas encore suffisamment vu comment manipuler les séquences pour faire énormément de programmes intéressants, nous allons quand même imaginer deux petits exercices, que nous allons réaliser ensemble, pour illustrer ce que nous avons déjà vu.

D’après l’échelle de Saffir-Simpson, une tempête est définie si les vents enregistrés (vents moyens pendant une minute à une hauteur de 10 mètres) sont de 64 à 118 km/h. Au delà de 118 km/h, selon l’endroit dans le monde où l’on se trouve, on parle d’ouragan, de typhon ou de cyclone.

Les cyclones sont classés suivant leur force, par l’échelle de Saffir-Simpson allant de 1 à 5 :

Catégorie 1 : Vents de 119 à 153 km/h
Catégorie 2 : Vents de 154 à 177 km/h
Catégorie 3 : Vents de 178 à 209 km/h
Catégorie 4 : Vents de 210 à 250 km/h
Catégorie 5 : Vents supérieurs à 250 km/h

Un territoire qui subit des vents de catégorie 5 subira des dégâts considérables.

Supposons que l’on ait une liste mes_valeurs de valeurs entières positives correspondant aux vents maximums enregistrés aux Bermudes chaque année depuis l’an 2000 ; la composante 0 désignant l’an 2000, 1, 2001, ….

Par exemple, avec des chiffres totalement inventés:

mes_valeurs = [75, 200, 230, 260, 100, 80, 50, 45, 180, 100, 200, 63, 64, 65,\
        118, 119, 153, 154, 280]

HISTORIQUE_TEMPETES

Ecrivons une fonction historique_tempetes qui reçoit en paramètre formel la liste vent_max de ces valeurs et imprime pour chaque année si les îles ont subi une tempête ou un cyclone et si c’est le cas, de quelle catégorie.

Découpe de la fonction historique_tempetes

La fonction doit traiter chaque élément de la liste séquentiellement. Une instruction for est donc adaptée. Pour chaque élément, il faut tester dans quelle catégorie se trouve la valeur. Remarquons que l’on peut découper la valeur en 3 classes : 1) pas de tempête, 2) tempête, 3) cyclone d’une certaine catégorie. Pour ne pas avoir à plusieurs endroits dans le programme du code assez semblable, une fonction categorie semble indiquée : qui reçoit une valeur de vent supérieure à 118 km/h et renvoit un nombre entre 1 et 5 suivant la catégorie.

def categorie(vent):
   """renvoit la catégorie de cyclone enregistré en fonction du vent"""

   assert vent > 118 # sinon provoque une erreur dans le code

   if vent < 154:
       res = 1
   elif vent < 178:
       res = 2
   elif vent < 210:
       res = 3
   elif vent < 251:
       res = 4
   else: # catégorie 5
       res = 5
   return res

La fonction historique_tempetes peut par exemple être encodé comme suit :

def historique_tempetes(vent_max):
   """Affiche pour chaque année la catégorie de vents subis cette année là
   entrée : vent_max: liste des vents maximums enregistrés en km/h
   chaque année (composante 0 étant pour l'an 2000)"""

   annee = 2000
   for vent in vent_max:
       if vent < 64:
           print("En", annee, ": pas de tempête enregistrée")
       elif vent < 119:
           print("En", annee, ": il y a eu au moins une tempête mais pas de cyclone")
       else:
           print("En", annee, ": le plus gros cyclone enregistré était de catégorie",
           categorie(vent))
       annee += 1

qui peut être appelée avec la liste des valeurs :

historique_tempetes(mes_valeurs)

CYCLONE_ANNEE

Avec la même liste mes_valeurs des vitesses de vents maximums, écrivons une autre fonction : tempete_annee qui reçoit en paramètre, la liste vent_max et annee entre 2000 et 2018, et qui renvoie la catégorie de cyclone auquel a été confronté les îles cette année.

Nous supposons comme résultat possible, 0 pour aucun cyclone, et une valeur entre 1 à 5 comprises pour donner la catégorie de cyclone.

La fonction peut se définir comme suit :

def cyclone_annee(vent_max, annee):
   """renvoie la catégorie de cyclone à laquelle les îles ont été confrontées
   pour l'année annee à partir de 2000)"""

   assert annee >= 2000 # si annee est inférieur à 2000, provoque une erreur

   vent = vent_max[annee - 2000] # valeur de vent pour cette année
   if vent < 119: # pas de cyclone
       res = 0
   else:
       res = categorie(vent) # appel la fonction categorie pour déterminer la catégorie
   return res

qui peut être testée comme suit pour les années 2001 à 2003 et 2009 :

for i in (2001, 2002, 2003, 2009):
    print(cyclone_annee(mes_valeurs, i))

Ces deux exemples illustrent bien ce que nous avons vu jusqu’ici sur les séquences de données Python. L’activité suivante demande que vous codiez de façon autonome pour résoudre des problèmes qui se résolvent en utilisant des séquences. A vous de jouer!

MISES EN PRATIQUE AVEC UPYLAB

Comme mise en bouche autonome pour ce module, faites l’exercice 5.1 d’UpyLaB. Cet exercice vous demande de mettre en pratique la manipulation simple de tuples; dans ce cas des couples donnant des coordonnées dans un espace à deux dimensions.

Dans ce cours, nous dirons couple pour parler d’un tuple à deux composantes.

Notez que dans le projet Vasarely, nous utiliserons des couples ou des triples, c’est-à-dire des tuples à trois valeurs pour représenter des coordonnées de points dans un espace respectivement à deux ou à trois dimensions.

EXERCICE UPYLAB 5.1 (EXTERNAL RESOURCE)

UPYLAB 5.1

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Écrivez une fonction distance_points() qui, étant donnés deux points

(x_{1}, y_{1})

(x_{2}, y_{2})

reçus en paramètres sous forme de tuples, calcule et renvoie la distance euclidienne entre ces deux points. Pour rappel, la distance entre deux points

(x_{1}, y_{1})

(x_{2}, y_{2})

se calcule comme suit:

dist = (x 2 - x 1) 2 + (y 2 - y 1) 2 ------------------\sqrt

où

\sqrt{a}

est la racine carrée de

a

et correspond à

a^{1 / 2}

(

a

exposant un demi).

Entrez votre solution :

sans réponse

RASSEMBLER

Pour que vous puissiez faire l’exercice UpyLaB suivant, nous devons d’abord introduire deux mécanismes bien pratiques que Python offre en association avec les fonctions: l’opération qui consiste à rassembler (gather en anglais) et à la sous-section suivante, le mécanisme inverse. Commençons par le gather: sans entrer dans tous les détails, dans la définition d’une fonction Python, on peut rajouter une astérisque devant le seul ou le dernier paramètre. Par exemple :

def ma_fonction(*valeurs) :
    print("Le paramètre est un tuple valant :", valeurs)

Dans ce cas, les valeurs reçues lors de chaque appel, sont rassemblées dans un tuple.

Par exemple dans une console PyCharm :

>>> def ma_fonction(*valeurs):
 ...       print("Le paramètre est un tuple valant :", valeurs)
 ...
>>> ma_fonction(2,3,5,7)
Le paramètre est un tuple valant : (2, 3, 5, 7)
>>> ma_fonction(2,3)
Le paramètre est un tuple valant : (2, 3)
>>> ma_fonction()
Le paramètre est un tuple valant : ()
>>> ma_fonction(2)
Le paramètre est un tuple valant : (2,)

Notez comment un tuple vide ou un tuple d’un élément est dénoté. En particulier :

t = (2)

mettra l’entier 2 dans t (les parenthèses étant considérées comme faisant partie de l’expression arithmétique même si elles ne rajoutent rien).

La virgule dans (2,) permet donc de stipuler que l’on parle d’un tuple.

SÉPARER

L’inverse du gather est aussi possible et est appelé en anglais scatter (disperser) qui distribue les valeurs d’une séquence comme étant une séquence d’arguments lors de l’appel à une fonction.

Expliquons le scatter sur un simple exemple. La fonction prédéfinie max renvoie le maximum des valeurs transmises, soit sous forme de liste soit d’une séquence.

Ainsi analysons dans une console Pycharm, la séquence suivante :

>>> max('bonjour')
'u'
>>> max([3, 7, 2, 5])
7
>>> liste1 = [2, 5, 7, 3]
>>> liste2 = [1, 5, 21, -15]
>>> max(liste1, liste2)
[2, 5, 7, 3]
>>> max(*liste1, *liste2)
21

le premier max regarde parmi la séquence de lettres celle qui a la valeur maximale (pour la codification UTF-8)
le second, le maximum des valeurs de la liste
le troisième compare deux listes et celle qui commence par 2 est plus grande que celle qui commence par la valeur 1
la dernière instruction, « met à plat » les valeurs de liste1 et de liste2. Nous obtenons l’équivalent de max(2, 5, 7, 3, 1, 5, 21, -15) qui renvoie la valeur maximale soit 21.

A présent vous pouvez effectuer l’exercice UpyLaB 5.2 qui utilise le gather.

EXERCICE UPYLAB 5.2 (EXTERNAL RESOURCE)

UPYLAB 5.2

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Écrivez une fonction longueur(*points) qui prend en paramètres un nombre arbitraire de points de coordonnées

(x, y)

et calcule la longueur du trait correspondant. Pour calculer la longueur, il faut effectuer la somme de la longueur des segments qui composent le trait. Un segment de droite est composé de deux points consécutifs passés en paramètre. Pour rappel, la distance entre deux points

(x_{1}, y_{1})

(x_{2}, y_{2})

se calcule comme suit:

dist = (x 2 - x 1) 2 + (y 2 - y 1) 2 ------------------\sqrt

Pour simplifier, on suppose qu'il y a au moins 2 points passés en paramètre lors des appels à la fonction longueur

Conseil: utilisez la fonction distances_points(p1, p2) définie avant.

Entrez votre solution :

sans réponse

LE PROJET : INFORMATION PRÉLIMINAIRE

En fonction du parcours que vous suivez, vous devez ou non faire le projet associé au cours. En particulier, si vous réalisez le parcours bleu, ou le parcours rouge, il est temps de réaliser le projet.

Cette section donne l’énoncé du projet que nous vous proposons dans le cadre de ce cours en ligne.

Note

Si vous ne comptez pas faire de projet, nous vous proposons de parcourir quand même cette section;

vous pourrez encore décider de ne pas faire de projet comme vous aviez prévu ou bien d'en faire une partie ou finalement de le faire quand même pour ne pas vous handicaper des points que vous n'obtiendrez pas si vous ne le faites pas (50 points possibles).

En effet, sans avoir vu l’ensemble de la matière, nous avons déjà vu les instructions Python, la notion de fonction et une partie de la matière sur les séquences de données. C’est suffisant pour pouvoir réaliser un projet tel que celui que nous vous proposons.

PROJET VASARELY (OP ART)

Dans ce qui suit nous, donnons l’énoncé du projet que vous devez réaliser, baptisé « projet Vasarely » en référence à l’artiste Victor Vasarely qui a popularisé cette tendance. (« Pour en savoir plus sur cet artiste, n’hésitez pas à consulter la page dédiée suivante: Victor Vasarely.

ENONCÉ DU PROJET VASARELY

Description globale du projet

Il vous est demandé de réaliser un programme en Python produisant des tableaux d’art optique comme représenté par les figures ci-dessous avec différentes couleurs et déformations:

Exemple de pavage déformé (bleu, rouge, noir)

Autre exemple de pavage déformé (noir, blanc, gris)

Ces tableaux représentent des pavages hexagonaux, vu d’en haut, formés avec des losanges de couleurs différentes, déformés par une boule. Votre programme utilisera le module turtle, présenté au module 2 de ce cours, pour peindre vos tableaux.

Ce projet sera réalisé en deux étapes principales, comme expliqué dans les composants qui suivent.

ÉTAPE 1

Ecrire une fonction pavage qui dessine un pavage hexagonal sans déformation.

Première ligne inférieure peinte

Deux premières lignes inférieures peintes

Votre fonction pavage utilisera une fonction hexagone qui trace un hexagone de taille donnée et à un endroit de la fenêtre turtle spécifiés dans les paramètres. Nous avons déjà travaillé sur le code d’un pavé hexagonal dans les modules 2 et 4 de ce cours.

Grâce à la fonction hexagone, pavage va pouvoir tracer des lignes de pavés pour remplir la zone définie.

Pavage sans déformation

ÉTAPE 2

Il faudra ensuite adapter les fonctions hexagone et pavage pour tenir compte d’une déformation. La déformation proposée consiste à faire sortir (ou rentrer) une boule du pavage. Cette boule « pousse » donc le pavage qui se déforme. Le programme dessine la « vue d’en haut » du résultat sur le plan à deux dimensions (x, y), ce qui revient à « oublier » la troisième coordonnée z des points que l’on trace avec turtle. En géométrie dans l’espace, nous parlons d’une projection orthogonale sur les axes x, y ( avec z = 0).

La déformation

Définir le code de la déformation s’adresse aux personnes qui ont un très bon bagage en mathématique; plus particulièrement en géométrie et trigonométrie.

Si c’est le cas, et que vous avez quelques heures pour solutionner le problème, nous vous invitons à écrire le code de cette déformation sous la forme d’une fonction deformation qui calcule la nouvelle coordonnée d’un point reçu en paramètre, après déformation due à une boule dont le centre et le rayon sont également donnés en paramètre.

Comme ce cours n’est sûrement pas réservé aux seuls étudiants férus de mathématiques, si vous n’avez pas ce bagage ou que vous ne pouvez consacrer le temps pour le faire, vous obtenez la fonction deformation que nous vous fournissons dans la partie consignes.

Si vous avez décidé d’écrire entièrement le projet y compris la fonction deformation(p, c, r), le lien suivant vous donne accès aux explications formelles nécessaires pour y arriver cliquez ici : Explications sur la déformation du projet Vasarely.

LES CONSIGNES POUR VOTRE PROJET

Nous travaillons avec des coordonnées et distances telles que manipulées par les différentes fonctions de turtle (up, begin_fill, goto, …). Nous vous demandons de réaliser quatre parties.

PARTIE 1

Pour aider la fonction pavage: d’écrire une fonction hexagone(t, c, longueur, col1, col2, col3, deformation, centre, rayon) qui reçoit : la tortue t le centre c sous forme d’un triple (tuple de trois composantes) donnant la valeur des trois coordonnées, du point avant déformation où l’hexagone doit être peint la distance (avant déformation) longueur entre le centre et n’importe quel coin de l’hexagone les trois couleurs col1, col2, col3 la fonction deformation(p, centre, rayon) qui elle-même reçoit en paramètre un point p sous forme de triple donnant les trois coordonnées du point p = (p_x, p_y, p_z), un point centre sous forme de triple donnant les trois coordonnées du centre de la sphère centre = (c_x, c_y, c_z) et rayon (float) le rayon de la sphère de déformation, et renvoie le point p2 = (x2, y2, z2) après déformation, le point centre sous forme de triple (c_x, c_y, c_z) qui donne le centre de la sphère de déformation, et le rayon de la sphère de déformation. La fonction peint un hexagone déformé en traçant des lignes droites entre le centre et les extrémités dont la position est calculée avec la fonction deformation.

col1 représente la couleur du pavé Nord-Est (en haut à droite), col2 représente la couleur du pavé Ouest (à gauche) et col3 représente la couleur du pavé Sud-Est (En bas à droite).

Note

Pour tester votre fonction, vous pouvez dans un premier temps définir la fonction deformation comme suit :

def deformation(p, c, r):
    return p

qui renvoit le point p sans y toucher.

PARTIE 2

D’écrire ou de télécharger la fonction deformation(p, c, r) avec:

p (tuple (p_x, p_y, p_z)) : le point à déformer
c (tuple (c_x, c_y, c_z)) : le point central de la sphère de déformation
r (float) : le rayon de la sphère de déformation

Si vous décidez de télécharger la fonction deformation, vous devez importer le fichier deformations.py en cliquant sur le lien suivant:

cliquez ici : deformation(point, centre, rayon)

Ensuite vous devez mettre le fichier dans le répertoire courant où votre code se fera exécuter et dans votre code vous devez faire un import :

from deformation import deformation

qui importe la fonction deformation du module deformation

Pour ceux qui veulent définir deformation eux mêmes (attention la théorie et le code sont beaucoup plus difficiles que tout ce que nous avons fait jusqu’à présent) ou simplement simplifier notre code qui nous semble bien loin d'être optimal (nous n'avons pas fait appel à des mathématiciens pour l'écrire ou même pour déterminer comment résoudre le problème) :

voici les explications de base en cliquent ici

et voici quelques conseils ou remarques :

Vous pouvez utiliser la librairie math
Les calculs se font sur des points en trois dimensions.
Le pavage avant déformation se trouve sur le plan avec z = 0.

Note

notons que nous nous simplifions le problème lors du tracé des hexagones déformés : en effet après calculs des déplacements des points extrémités grâce à la fonction deformation, le programme tracera des lignes droites (et non pas des lignes déformées) entre ces extrémités. Ne vous en faites pas: l’effet final n’en est que peu affecté.

Conseil: pour tracer les hexagones utilisez la méthode goto(x,y) de turtle plutôt que forward.

Exemple d’hexagone avant et après transformation

Exemple de pavé hexagonal non déformé

Hexagone de centre (0,0,0) de longueur d’arête avant déformation 30 avec déformation de centre (-50, -50, 0) et de rayon 90 (en rose, les contours du pavé avant déformation)

PARTIE 3

D’écrire une fonction :

pavage(t, inf_gauche, sup_droit, longueur, col1, col2, col3, deformation, centre, rayon)

qui reçoit :

la tortue t ;

des valeurs inf_gauche, sup_droit donnant une fenêtre dont le coin inférieur gauche est (inf_gauche, inf_gauche) et le coin supérieur droit est (sup_droit, sup_droit) sachant que l’on représente uniquement les axes x et y, la hauteur du pavage avant transformation étant égale à 0 ;

la longueur entre le centre et n’importe quel coin de chaque hexagone avant déformation ;

les trois couleurs col1, col2, col3 ;

la fonction deformation telle que décrite plus haut ;

le centre de cette déformation utile pour la fonction deformation ;

le rayon de la sphère de déformation utile pour la fonction deformation.

La fonction pavage peint les hexagones déformés dont les centres, avant déformation, se trouvent dans la fenêtre (les bords inclus) avec l’hexagone en bas à gauche, avant déformation, centré sur le point (inf_gauche,inf_gauche). Pour cela, elle utilise la fonction hexagone.

La séquence de couleurs est la même pour tous les pavés du pavage (tout les losanges en haut à droite du pavé sont de col1, à gauches de col2 et en bas à droite de col3.

Que vous définissiez vous même la fonction deformation ou que vous preniez la nôtre, de toute façon, n’oubliez pas que turtle ne tient compte que des deux premières dimensions. La valeur de z des points n’étant pas envoyée par exemple aux goto(x,y).

Les couleurs possibles sont données par la spécification de couleur Tk, voir : Couleurs et Couleurs2

PARTIE 4

Enfin, d’écrire un code principal qui demande à l’utilisateur ce qu’il désire comme paramètres (couleurs, longueur des segments, …) et qui appelle la fonction pavage pour réaliser le résultat.

Les paramètres seront donnés comme suit:

inf_gauche : (valeur entière) donnant les coordonnées (inf_gauche, inf_gauche) du bord inférieur gauche de la fenêtre de visualisation ;
sup_droit : (valeur entière) donnant les coordonnées (sup_droit, sup_droit) du bord supérieur droit de la fenêtre de visualisation ;
longueur : (valeur entière) longueur d’un segment de pavé (avant déformation) ;
col1 : (chaîne de caractères) donnant la première couleur des pavés ;
col2 : (chaîne de caractères) donnant la deuxième couleur des pavés ;
col3 : (chaîne de caractères) donnant la troisième couleur des pavés ;
centre : (trois entiers) donnant les coordonnées du centre de la sphère déformante
r : (entier) donnant rayon de la sphère déformante.

Par exemple les entrées de votre programmes seront :

-300
300
20
red
black
blue
-50 -50 -50
200

Après la réalisation du travail, votre programme demandera à turtle de sauver le résultat dans un fichier. Pour cela, votre programme pourra exécuter l’instruction:

turtle.getcanvas().postscript(file="pavage.eps")
turtle.done()

où ici le nom du fichier est "pavage.eps". Notez que le seul format de fichier possible pour turtle est postscript (suffixe eps). Si, après l’exécution du programme, vous désirez un autre format pour le fichier résultat (jpeg ou pdf par exemple) il vous suffira de faire traduire le résultat, par exemple en utilisant une traduction en ligne (avec votre navigateur web, cherchez online translation eps to jpg par exemple).

Au terme de votre projet, si vous le désirez, un exemple de résultat de votre code, avec les couleurs et déformations que vous désirez, pourra être publié et visible par tous. Utilisez le forum du Projet pour toute question concernant l’énoncé.

EXEMPLES DE RÉSULTATS

Le tableau au début de l’énoncé a été généré avec les paramètres

inf_gauche = -300
sup_droit = 300
longueur = 20
col1 = 'blue'
col2 = 'black'
col3 = 'red'
centre = (-50, -50, -50)
r = 200

Le second exemple en début d’énoncé est produit avec les mêmes paramètres, mis à part :

col1, col2, col3 = 'white', 'black', 'grey'
centre = (-100, -100, 0) et
rayon = 300

L’exemple ci-dessous a les mêmes paramètres que celui donné au début, mis à part

centre = (-50, -50, 0) et
rayon = 240

Pavage avec centre = (-50, -50, 0) et rayon = 240

COMMENT DANS PYCHARM SAUVER UN CODE PYTHON

Notez que si vous avez travaillé dans un fichier scratch de Pycharm et désirez sauver votre code dans un répertoire précis de votre ordinateur, dans Pycharm, vous devez

cliquer sur le menu File sous-menu Save As… et
donner le nom du fichier avec le suffixe .py pour exprimer qu’il s’agit de code python (par exemple projetVasarely.py) ainsi que le répertoire (Directory) où il doit être sauvé (Par exemple /Users/tmassart/PycharmProjects/MOOC).

CONSIGNES À RESPECTER POUR LE PROJET

Consignes sur le contenu du projet

Les consignes décrites dans les sous-sections précédentes sont à respecter scrupuleusement ; relisez-les attentivement avant la remise!

Echéances

Consultez le calendrier pour connaitre la date limite de remise.

Modalités de remise

La procédure de remise sera expliquée dans le module "Projet" (disponible une semaine plus tard) , consacré à la soumission et à l'évaluation du projet.

MAIS COMMENT ÉVALUER UN PROJET ?

De façon binaire nous pourrions dire qu’un programme informatique est bon s’il fait ce qu’on lui demande et sinon il est incorrect. Ce serait un peu court surtout après avoir parlé de toutes les règles de bonnes pratiques que nous avons vues.

En fait, un projet tel que le projet Vasarely, est évalué selon plusieurs critères de correction (programme correct, qui fait bien son travail) et de style (code qui suit les règles de bonnes pratiques).

Donnons ici des recommandations pour évaluer un projet de programmation niveau débutant.

Principes de base

La réalisation d’un projet informatique comprend plusieurs aspects qui font l’objet de choix qui doivent généralement être justifiés, ou de mise en application, généralement sous forme de programme structuré.

Tout d’abord, il est important que l’évaluation soit le résultat d’une notation

positive: qui consiste à donner des points quand certains aspects sont présents dans la solution, et
négative: qui consiste à enlever des points sur certains aspects qui sont absents ou incorrects.

Il convient aussi in fine d’avoir une évaluation globale où un projet qui fonctionne se voit naturellement attribuer des points même si plusieurs problèmes existent dans la réalisation.

Le mieux pour obtenir une telle note qui est le fruit d’une évaluation négative et positive, est de découper la note finale en sous notes, qui chacune évalue un aspect (qui de même fait l’objet d’une évaluation négative et positive avec évaluation globale.

Proposition

Ci dessous la découpe de la note à donner au projet, que nous vous demandons d’appliquer dans vos évaluations pour obtenir une notation uniforme pour tous. Le nombre de points pour chaque catégorie est proposée pour une note finale sur 25 points. Comme il s’agit d’un projet pour débutant, les structures de données et les méthodes pour résoudre les problèmes sont données et ne nécessitent pas de recherche pour l’apprenant; aucune note n’est donc donnée pour ces deux aspects.

Grille de notation du projet (sur 25 points)

Découpe (4 points) : La découpe du code global avec commentaires
initiaux, et respect de l’ordre des parties : import des modules externes, suivit des définitions des constantes globales, suivit des définitions des fonctions et enfin, code global.
- 4 points si les quatre parties sont présentes et l’ordre est respecté ;
- 3 points si une des quatre parties manquent ou est dans le mauvais ordre ;
- 2 points si deux des quatre parties manquent ou sont dans le mauvais ordre ;
- 1 points si trois des quatre parties manquent ou sont dans le mauvais ordre ;
- 0 point si rien n’est satisfaisant.
Structuration en fonctions (4 points) : La structuration en
fonctions de bonne taille (25 lignes maximum hors docstrings) et cohérente (pas de fonctions définies mais non appelées par exemple) est réalisée :
- 4 points la structuration est satisfaisante ;
- 3 points si des fonctions sont définies, mais certaines sont soit incohérentes soit sont trop longues ;
- 2 points si des fonctions sont définies, mais certaines sont incohérentes et d’autres sont trop longues ;
- 0 point si aucune fonction n’est définie
Bonnes pratiques (4 points) : Les bonnes pratiques sont
respectées en matière d’utilisation des noms des constantes, variables, fonctions…, de l’indentation… :
- 4 points si toutes les bonnes pratiques sont respectées ;
- 3 points si les noms des constantes, variables et fonctions respectent les bonnes pratiques, mais l’indentation (4 caractères par incrément) n’est pas respecté ;
- 2 points les règles sont globalement repectées à quelques exceptions prêt à la fois au niveau indentations et noms de constantes, variables ou fonction ;
- 0 points si les règles de bonnes pratiques en matière d’encodage ne sont globalement pas respectées.
Commentaires (4 points) : Commentaires et docstrings sont bien
présents : (le docstring initial possède les informations suivantes : identité de l’auteur, date, ce que fait le programme, les fonctions possèdent un docstring décrivant les paramètres, ce que fait la fonction aux paramètres (par défaut, ils ne sont pas modifiés) et le résultat de la fonction, des commentaires pertinents existent quand c’est utile à la compréhension)
- 4 points si commentaires et doctsrings sont présent et respectent les règles de bonnes pratiques ;
- 3 points un des éléments docstring initial ou commentaires est manquant ou non satisfaisant ;
- 2 points si le docstring initial et les commentaires sont manquants ou non satisfaisants, ais que les fonctions ont des docstrings corrects ;
- 0 point si les trois éléments docstring initial, commentaires et docstrings de fonctions sont manquants ou non satisfaisants.
Consignes (2 points) : (voir énoncé du projet)
- 2 points si les consignes du projet sont respectées ;
- 1 points si la moitié des consignes est respectée ;
- 0 points si auncune consigne n’est respectée.
Résultat (7 points) : Le programme fonctionne correctement.
- 7 points si c’est le cas ;
- 6 points si le programme donne les bons résultats sur la plupart des jeux de données ;
- 4 points si le programme donne le bon résultat sur au moins un jeu de données ;
- 2 points si le programme s’exécute sans échec sur au moins un jeu de données ;
- 0 points si le programme ne s’exécute pas sans échec.

Explication sur l’évaluation

En plus des points attribués, il est essentiel pour l’évaluateur, d’expliquer pourquoi telle ou telle note a été donnée, pour que l’auteur du projet puisse comprendre les notes données et puisse s’améliorer les fois suivantes.

MAIS COMMENT ALLEZ-VOUS ÊTRE ÉVALUÉ SUR VOTRE PROJET ?

Dans le cadre de ce cours, comme annoncé, l’évaluation de votre projet, réalisé au module "Projet", se fera en deux temps :

d’une part par une évaluation par les pairs
d’autre part, par une auto-évaluation de votre projet après éventuelles améliorations.

En pratique, la remise du projet et son évaluation sera fait en 5 étapes :

Après l’avoir réalisé, vous soumettrez votre projet éventuellement avec un fichier supplémentaire montrant un résultat ;
Vous devrez évaluer trois projets d’autres étudiants choisis au hasard ;
Vous recevez les notes et commentaires sur votre propre projet venant d’au moins deux autres de vos pairs (deux autres apprenants) ;
A la lumière des commentaires donnés par vos pairs, vous corrigez et soumettez une version améliorée de votre projet
Vous réalisez une auto-évaluation, c’est-à-dire évaluez votre propre projet.

Le document téléchargeable ici reprend les explications et détaille chaque notation et demande de commenter chaque note donnée.

Quand cela sera fait, et quand votre projet aura été évalué par deux pairs, vous recevrez ces évaluations et les commentaires qui les accompagnent. Avec ces évaluations, vous devrez procéder à une auto-évaluation de votre travail: en clair évaluer votre propre travail à la lumière des commentaires donnés par vos pairs.

La note finale de votre travail sera la somme des évaluations par les pairs (25 points) et de votre auto-évaluation (25 points).

Les détails pratiques sur les évaluations seront donnés au module 'Projet'.

Temps et Délais pour réaliser le projet

L’estimation du temps moyen que va vous mettre le projet Vasarely (en supposant que vous utilisez la fonction deformation qui vous est fournie), est d’une dizaine d’heures y compris la partie évaluation. La matière vue jusqu’ici suffit pour sa réalisation. Vous avez plusieurs jours pour sa remise. Libre à vous de mener en parallèle la suite du module 5 avec la réalisation du projet.

Mais nous ne vous le conseillons pas. En effet, notre expérience est qu’il est sans doute plus simple de ne pas tout faire en même temps, et donc de postposer la suite de l’apprentissage du module 5 et de vous atteler dès maintenant au projet. Après, vous pourrez reprendre les modules 5 et 6. La partie évaluation du projet se fera dans le module "Projet".

REVENONS À NOS SÉQUENCES

L’énoncé du projet est donné; vous l’avez sans doute déjà entamé; et peut être même terminé.

Nous voici de retour pour apprendre de la nouvelle matière sur les séquences. nous avons vu que les séquences permettent de stocker plusieurs valeurs soit de type texte avec les chaînes de caractères, soit de différents types pour les tuples et les listes. il nous reste à voir beaucoup de matière dans ce gros module sur les séquences, en terme de manipulations plus sophistiquées. en particulier, nous allons voir comment modifier des séquences, par exemple pour ajouter des éléments ou en supprimer.

Continuons donc à découvrir d’autres façons de manipuler les séquences.

Trois capsules vidéo sont proposées ici :

la première vidéo présente la notion de tranche et comment étendre une liste ;
la seconde présente la notion de diagramme d’état, qui va nous permettre de bien comprendre comment l’interpréteur python gère les séquences dans la mémoire du programme.
la dernière vidéo présente des séquences imbriquées, et les notions d’emballage et de déballage (pack / unpack)

TRANCHE DE SÉQUENCE

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

GESTION MÉMOIRE DES SÉQUENCES EN PYTHON

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

SÉQUENCE IMBRIQUÉES, EMBALLAGE ET DÉBALLAGE (PACK/UNPACK)

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

MAIS EN FAIT C’EST QUOI UNE SÉQUENCE PYTHON ?

Avant de mettre en pratique ce que nous avons vu dans les vidéos qui précèdent, revenons brièvement aux notions de base. Comme déjà mentionné au module 2, Python manipule des objets contenant les valeurs et des variables qui sont des noms pour les objets. Ainsi

prem = sec = [2, 3]

crée un objet de type liste contenant deux sous-objets entiers valant respectivement 2 et 3 ; prem et sec sont deux noms donnés à cet objet de type liste. En fait le terme Python approprié n’est pas type mais classe liste. Les notions de classe et d’objet sont liées au fait que Python est un langage orienté-objet. Nous n’en dirons pas beaucoup plus dans ce cours qui n’aborde pas ces concepts avancés de Python.

Ce qui est important à savoir maintenant est qu’une classe, comme la classe liste, est définie avec des attributs et aussi des méthodes. Nous avons vu dans la première video de cette sous-section, les méthodes append et extend. De façon générale, une méthode réalise un certain traitement sur un objet de cette classe (par exemple prem.append(666) qui ajoute une composante à la liste prem, ayant la valeur entière 666).

La syntaxe pour utiliser une méthode est le nom de l’objet, suivi d’un point suivi du nom de la méthode et terminé par les arguments entre parenthèses; les parenthèses étant obligatoires même s’il n’y a pas d’arguments.

La section suivante (après celle contenant le quiz), est consacrée à l’apprentissage de nombreuses méthodes associées aux séquences ; celles-ci vont nous permettre assez facilement de réaliser une multitude de traitements.

RELEVÉES DES PLUIES COMME ILLUSTRATION DES SÉQUENCES

Illustrons les manipulations de listes sur un exemple complet que nous allons développer ensemble dans cette activité. Ce sera également l’occasion de montrer quelques techniques classiques utilisées par les programmeurs Python.

Supposons que nous voulions récolter les valeurs des précipitations de pluie, pour un mois de l’année, par exemple septembre, pour ensuite pouvoir communiquer ces valeurs à la demande.

Dans cette section, nous partons d’un code pluie_1.py sans séquence qui ne répond que très partiellement au problème et construisons le code pluie_2.py, qui manipule une séquence de données pour mieux y répondre. Ce sera l’occasion de discuter sur les façons classiques pour initialiser des séquences de données. Avec tout ce bagage en plus, en fin de section nous produisons, avec le code pluie_3.py, une version complète et structurée avec des fonctions répondant au problème.

PLUIE_1.PY

Partons d’un programme sans séquences qui calcule les valeurs cumulées de pluies collectées pendant le mois de septembre.

""" programme qui somme les pluies pour septembre
   les valeurs quotidiennes sont entrées (input)
   et la somme est affichée en sortie"""
somme_pluie = 0
for i in range(1, 31): # du jour 1 au jour 30 (31 n'est pas inclus!)
   val = int(input("pluie cumulée le " + str(i) + " septembre :"))
   somme_pluie += val
print("pluie cumulée pour le mois de septembre :", somme_pluie)
print("Au revoir et merci ! ")

Code pluie_1.py

Notons :

l’utilisation de str() qui traduit la valeur i en texte; associé à l’opérateur de concaténation +, il permet de donner un seul paramètre de type chaîne de caractères à la fonction input(), et
l’utilisation de l’opérateur += pour cumuler dans la variable somme_pluie, au départ initialisée à 0, les valeurs des pluies cumulées.
le range(1,31) dans le for pour que l’indice i corresponde au jour concerné de septembre.

PLUIE_2.PY

Supposons maintenant que nous désirions enregistrer les valeurs individuelles lues, ainsi que la somme des valeurs cumulées, pour pouvoir faire plus de manipulations de valeurs.

Le code suivant propose une solution en ce sens :

""" programme qui enregistre les valeurs quotidiennes
   des pluies pour septembre, entrées (input)
   et affiche en sortie, les valeurs de pluie demandées
   (0 pour le cumul des valeurs)"""

# 1) collecte des données
pluie_septembre = [0] * 31 # crée une liste de 31 composantes initialisées à 0
for i in range(1, 31):
   pluie_septembre[i] = int(input("pluie cumulée le " +str(i) + " septembre :"))
# calcule la somme dans la composante 0
pluie_septembre[0] = sum(pluie_septembre)

# 2) communication des valeurs à la demande
print("Donnez le jour dont vous désirez la valeur des pluies cumulées"
     "(0 pour avoir tout le mois et -1 pour terminer)")
jour = int(input("Jour :"))
while jour > -1 and jour < 31:
   print(pluie_septembre[jour])
   jour = int(input("Jour :"))
print("Au revoir et merci ! ")

Code pluie_2.py

Notons que :

le code commence par se créer une variable pluie_septembre de type liste à 31 composantes (d’indice 0 à 30) contenant des 0;
les composantes i de pluie_septembre sont mises à jour
ensuite la composante 0 reçoit la somme des composantes
enfin, le code renvoie les valeurs demandées jusqu’à ce que l’utilisateur envoie une valeur -1 pour signifier qu’il ne désire plus que le code affiche des valeurs.

LES TECHNIQUES DE LECTURE ET D’INITIALISATION D’UNE SÉQUENCE

Les codes pluie_1.py et pluie_2.py montrent comment on peut initialiser une liste avec des valeurs lues avec input. Comme la lecture et l’initialisation de séquences de données (chaînes de caractères, tuples ou listes) sont des traitements fréquents en programmation, il est important ici d’ouvrir une parenthèse et de discuter sur quelques techniques classiques pour le faire en Python.

Lecture et initialisation d’une chaîne de caractères c

Cette opération est aisée puisque l’instruction input() le permet directement avec :

s = input()

où s est la variable qui reçoit la chaîne de caractère lue.

Lecture et initialisation d’un tuple de valeurs

Si l’on suppose que l’utilisateur introduit la séquence de valeurs en mettant une virgule entre chaque valeur le tout sur une seule ligne, l’utilisation de la fonction prédéfinie eval() peut être faite. Regardons ce que fait la fonction eval :

eval(texte)

évalue le contenu de la chaîne de caractères fournie en argument comme s’il s’agissait d’une expression Python, et renvoie le résultat. Par exemple :

eval("2 + 2")

renvoie la valeur entière 4.

Si le texte fourni à eval est une chaîne de valeurs séparées par des virgules (par exemple : 2, 3, 5, 7), eval renvoie un tuple. Dans ce cas, le code suivant assigne à s le tuple créé par eval :

s = eval(input())

Si lors de l’exécution de l’instruction ci-dessus, l’utilisateur introduit la ligne :

"le serpent", "le mouton", "le petit prince", "l'aviateur", "la rose"

après son exécution, s vaudra le tuple :

("le serpent", "le mouton", "le petit prince", "l'aviateur", "la rose")

Lecture et initialisation d’une liste de valeurs entières: les programmes pluie_1.py et pluie_2.py montrent comment le travail peut être réalisé.

Si la taille de la liste est connue, en gros, le code peut avoir la forme suivante :

s = [None] * n
for i in range(n):
   s[i] = int(input())

où n est une valeur entière donnant le nombre d’éléments à initialiser (n = 31 par exemple). L’utilisateur du programme tape sur la touche return du clavier après chaque donnée introduite.

Dans ce cas, le code commence par créer une liste avec le bon nombre n de composantes, initialisées avec des valeurs quelconques (0, None, …), valeurs qui ne sont pas utilisées et sont changées dans l’instruction for qui suit.

Si le nombre d’éléments est inconnu, la méthode append peut être utilisée. Dans ce cas, une technique classique est de demander à l’utilisateur d’entrer une donnée à la fois, et à la fin, d’introduire une valeur convenue, appelée généralement valeur sentinelle (par exemple -1 si les données sont toutes positives) pour signifier que la liste des valeurs communiquées est terminée. La forme du code est la suivante :

FIN_DES_VALEURS = -1 # valeur sentinelle qui quand elle est lue
                                         # indique la fin des données
...
s = []
i = int(input())
while i != FIN_DES_VALEURS :
   s.append(i)
   i = int(input())

La même technique utilisant la fonction prédéfinie eval() pour initialiser un tuple peut être employée pour créer un liste. Il suffit que l’utilisateur encode la liste sur une ligne. Par exemple l’exécution de l’instruction:

s = eval(input())

avec comme entrée:

[2, 3, 5, 7]

initialise s avec la liste correspondante.

Création d’une séquence à partir d’une autre

Analysons d’autres cas de figure.

Types différents :

Si les données que le programme désire utiliser pour créer une séquence sont déjà présentes dans une autre séquence s d’un autre type, les fonctions prédéfinies tuple, list, et str peuvent être utiles.

Ces fonctions ont comme seul paramètre, la séquence préexistante.

list(s) essaye de changer le type du paramètre s en liste,
tuple(s) essaye de changer le type du paramètre s en tuple,
str(s) crée une chaîne de caractères qui correspond à ce qui serait imprimé par un print(s).

Par exemple, ayant un tuple s valant (2, 3, 5, 7, 9)

t = list(s)

assigne à t la liste [2, 3, 5, 7, 9]

Autre exemple:

t = list("bonjour")

assigne à t une liste de 7 composantes où chacune est un caractère du texte "bonjour"

Mêmes types :

Créer une séquence t de type tuple ou chaîne de caractères avec une séquence s de même type, se fait par une simple assignation. Comme les listes sont modifiables, une simple assignation ne suffit en général pas dans ce cas, et il faut faire une copie. La copie de listes sera vu plus en détail en section 5.7.

PLUIE_3.PY

Après cette partie de cours explicative sur l’initialisation de séquences, discutons du programme pluie_3.py dont le but est de donner une version complète et structurée du code qui effectue relevé et communication des données de pluie pour une période donnée.

Pour améliorer la structure du code, pluie_3.py sera donc composé des deux fonctions :

collecte_donnees qui construit la liste des valeurs
affiche_valeur qui affiche une information demandée: ajoutons la possibilité de demander les pluies sur une période entre deux jours; par exemple du 3 au 10.

Donnons la fonction collecte_donnees qui construit et renvoie la liste :

def collecte_donnees(nb_jours):
  """construit et renvoie une liste avec dans la composante i,
     les valeurs entières lues de pluie cumulée du jour i
     et en composante 0, la somme des pluies pour le mois entier
  """

  # la composante 0 pour enregistrer les pluies cumulées du mois
  pluie = [0]

  # reçoit les valeurs
  for i in range(1, nb_jours + 1):  # jours 1 à nb_jours inclus
      pluie.append(int(input("pluie cumulée le " + str(i) +\
                             " du mois :")))

  # calcule la somme dans la composante 0
  pluie[0] = sum(pluie)

  return pluie  # renvoie la liste construite

Notons que l’exécution de l’instruction

pluie.append(int(input("texte")))

commence par afficher le texte,
ensuite fait l'input
traduit la chaîne de caractères reçue en int
ajoute un composant à la liste pluie
assigne la valeur entière lue à ce nouveau composant.

La liste pluie créée, est renvoyée au « programme appelant ».

Donnons la fonction affiche_valeur qui reçoit la liste avec les valeurs (paramètre formel pluie) et la requête; celle-ci est soit sous la forme d’une valeur entière entre 0 et 31 (30, 29 ou 28 si nous traitons un mois avec moins de jours), 0 étant la valeur cumulée du mois stockée en composante 0, soit d’un couple de valeurs (début, fin) donnant la période dont l’utilisateur veut les pluies cumulées; affiche_valeur affiche l’information demandée avec des instructions print.

def affiche_valeur(pluie, requete):
  """ Affiche la valeur de pluie demandée
      si requete est un entier entre 1 et 31 : donne la pluie de ce jour
      si requete est un entier valant 0 : donne la pluie cumulée du mois
      si requêtre est un couple : donne la valeur des pluies cumulées dans l'intervalle
  """

  if type(requete) == int:  # suppose que requête est entre 0 et 31
      # et que pluie[requete] existe
      if requete == 0:  # demande pluie cumulée
          print("Pluie cumulée du mois :", pluie[requete])
      else:
          print("Pluie le", requete, ":", pluie[requete])
  else:  # requete est un couple de valeurs
      print("Pluie cumulée entre le", requete[0], "et le",
            requete[1], ":", sum(pluie[requete[0]: requete[1] + 1]))

Notons :

les tests sur le type et la valeur de la variable requete ;
l’instruction print("...", sum(pluie[requete[0]: requete[1]+1])) qui calcule la somme des valeurs de pluie entre requete[0] et requete[1] incluse et l’affiche avec print.

Il nous reste à donner le code principal qui appelle les fonctions collecte_donnees et affiche_valeur.

# main - code principal
pluies_septembre = collecte_donnees(30)  # lecture données
# délivre les informations désirées
print("Donnez le jour 'j' ou la période 'i, j'",
    "dont vous désirez la valeur des pluies cumulées")
print("(0 pour avoir tout le mois et -1 pour terminer)")
jour = eval(input("Jour ou période ? :"))
while jour != -1:
  affiche_valeur(pluies_septembre, jour)
  jour = eval(input("Jour ou période ? :"))
print("Au revoir et merci ! ")

Notons l’instruction jour = eval(input("Jour ou période ? :")) qui utilise la fonction prédéfinie eval comme expliqué plus haut dans cette section. Dans ce cas,

si l’utilisateur a introduit 7 : jour est un entier,
si l’utilisateur a introduit 3,10 : jour est un couple (tuple) d’entiers

Code de pluie_3.py

Le code complet du programme pluie_3.py peut être obtenu en cliquant sur le bouton suivant :

EXERCICES UPYLAB 5.3 À 5.7

Nous voici au terme de cet exercice qui nous a permis d’illustrer les manipulations vues jusqu’ici de séquences listes, tuples et chaînes de caractères; et également de voir comment initialiser de telles séquences.

Passons à l’apprentissage autonome de la matière vue jusqu’ici sur les séquences.

Réalisez les exercices 5.3, 5.4, 5.5, 5.6 et 5.7 d’UpyLaB. Ces exercices vont vous permettre de manipuler les séquences, leurs composantes, tranches ainsi déjà que les méthodes déjà vues sur ces séquences de données.

EXERCICE UPYLAB 5.3 (EXTERNAL RESOURCE)

UPYLAB 5.3

(2 points possibles)

Parcours : bleu rouge

Enoncé

On vous demande d’écrire une fonction plus_grand_bord(w) qui, étant donné un mot w, retourne le plus grand bord de ce mot. On dit qu’un mot u est un bord de w, si u est à la fois un préfixe strict (c’est-à-dire un texte avec la première partie du texte w non vide et non égal à w lui-même) de w et un suffixe strict (c’est-à-dire un texte avec la dernière partie du texte w non vide et non égal à w lui-même) de w. Si w n’a pas de bord, la fonction retourne une chaîne de caractères vide.

Exemple : 'a' et 'abda' sont des bords de 'abdabda'

En effet:

'abdabda' à la fois commence et se termine par 'a'

De même 'abdabda' à la fois commence et se termine par 'abda'('abdabda' et 'abdabda')

Le plus grand bord est 'abda'.

Entrez votre solution :

sans réponse

EXERCICE UPYLAB 5.4 (EXTERNAL RESOURCE)

UPYLAB 5.4

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Ecrire une fonction trans(text, replaceA, replaceB), qui reçoit trois paramètres:

text : une chaîne de caractères
replaceA : un couple (oldA, newA) où oldA est un caractère et newA un texte
replaceB : un couple (oldB, newB) où oldB est un caractère et newB un texte

et qui renvoie le résultat de la transformation suivante : chaque occurrence du symbole "oldA" dans la chaîne text est remplacée par la chaîne "newA", et simultanément chaque occurrence du symbole "oldB" est remplacée par la chaîne "newB".

Pour simplifier, vous pouvez supposer que "oldA" est différent de "oldB"

Exemple:

>>> print(trans('ABBAB', ('A','AB'), ('B','BA')))
>>> 'ABBABAABBA'

Entrez votre solution :

sans réponse

EXERCICE UPYLAB 5.5 (EXTERNAL RESOURCE)

UPYLAB 5.5

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Écrivez une fonction duree qui prend deux paramètres debut et fin. Ces derniers sont des couples (tuples de 2 composantes) dont la première composante représente une heure et la seconde composante représente les minutes. Cette fonction doit calculer le nombre d'heures et de minutes qu'il faut pour passer de debut à fin.
Exemple : un appel à duree ((14, 39), (18, 45)) renvoie (4, 6) pour 4 heures et 6 minutes.
Notez qu'un appel à duree ((6, 0), (5, 15)) renvoie (23, 15) pour 23 heures et 15 minutes, et non (0, 45) !

Entrez votre solution :

sans réponse

EXERCICE UPYLAB 5.6 (EXTERNAL RESOURCE)

UPYLAB 5.6

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Voici le début d'une suite logique inventée par John Horton Conway (et donc appelée suite de Conway) :

1211

111221

312211

...

Chaque ligne à partir de la deuxième décrit la précédente...

La première ligne : 1,
on l'a décrit "Un 1" ce qui donne la deuxième : 11,
la troisième décrit la deuxième : "Deux 1" : 21
la quatrième décrit la troième : "Un 2 suivi de Un 1" : 1211
et ainsi de suite.

On vous demande d'écrire une fonction next_line(line) qui prend une liste d'entiers décrivant une ligne de cette suite et qui calcule et retourne la liste correspondant à la ligne suivante. Par exemple :

next_line([1,2,1,1])

retourne la liste [1,1,1,2,2,1]

Par convention, next_line([]) retourne la liste [1]

Entrez votre solution :

sans réponse

EXERCICE UPYLAB 5.7 (EXTERNAL RESOURCE)

UPYLAB 5.7

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Ecrivez une fonction my_pow qui prend comme paramètres un nombre entier m et un nombre flottant b et qui renvoie une liste contenant les m premières puissances de b, c'est-à-dire une liste contenant les éléments allant de

b^{0}

b^{m - 1}

Si le type des paramètres n'est pas celui attendu, votre fonction renverra la valeur None

Entrez votre solution :

sans réponse

MINI QUIZ SUR LES SÉQUENCES

Avant de continuer l’étude des séquences Python, ce quiz va vous aider à vérifier que vous avez bien assimilé ce que nous avons vu jusqu’ici sur cette matière. Attention, vous n’avez droit qu’à un seul essai. Un conseil : si vous n'êtes pas sûr, vérifiez en regardant dans le cours ou le manuel Python (à l'adresse python.org) avant de répondre.

QUESTION 1 (UN SEUL ESSAI POSSIBLE)

(1 point possible)

Que fait le code suivant ? (un seul essai possible) :

```
texte = 'bonjour'
print(texte[1:4][1])
```

Vous avez utilisé 0 essais sur 1

QUESTION 2 (UN SEUL ESSAI POSSIBLE)

(1 point possible)

Que fait le code suivant ? (un seul essai possible) :

texte = 'bonjour'
ma_liste = [texte, texte]
print(ma_liste)

Vous avez utilisé 0 essais sur 1

QUESTION 3

(1 point possible)

Que fait le code suivant ? :

texte = 'bonjour'
t1 = [texte, texte]
t1[1] = "Hello"	
print(t1)

Vous avez utilisé 0 essais sur 1

QUESTION 4

(1 point possible)

Que fait le code suivant ? (un seul essai) :

texte = 'bonjour'
t1 = [texte, texte]
t2 = t1[:]
t1[1] = "Hello"
print(t2)

Vous avez utilisé 0 essais sur 1

QUESTION 5

(1 point possible)

Que fait le code suivant ? (un seul essai) :

def foo(liste):
    return [liste, liste]

x = [2,3]
x = foo(x)
print(x)

Vous avez utilisé 0 essais sur 1

DIAGRAMME D’ÉTAT

Il est intéressant de voir, en exécutant avec Python Tutor le code de la question 5 ci-dessous, les diagrammes d’état qui montrent que chaque composante de la liste globale construite pointe vers la même sous liste [2, 3] :

MINI QUIZ SUR LES SÉQUENCES

QUESTION 1 (UN SEUL ESSAI POSSIBLE)

(1 point possible)

Que fait le code suivant ? (un seul essai possible) :

```
texte = 'bonjour'
print(texte[1:4][1])
```

Vous avez utilisé 0 essais sur 1

QUESTION 2 (UN SEUL ESSAI POSSIBLE)

(1 point possible)

Que fait le code suivant ? (un seul essai possible) :

texte = 'bonjour'
ma_liste = [texte, texte]
print(ma_liste)

Vous avez utilisé 0 essais sur 1

QUESTION 3

(1 point possible)

Que fait le code suivant ? :

texte = 'bonjour'
t1 = [texte, texte]
t1[1] = "Hello"	
print(t1)

Vous avez utilisé 0 essais sur 1

QUESTION 4

(1 point possible)

Que fait le code suivant ? (un seul essai) :

texte = 'bonjour'
t1 = [texte, texte]
t2 = t1[:]
t1[1] = "Hello"
print(t2)

Vous avez utilisé 0 essais sur 1

QUESTION 5

(1 point possible)

Que fait le code suivant ? (un seul essai) :

def foo(liste):
    return [liste, liste]

x = [2,3]
x = foo(x)
print(x)

Vous avez utilisé 0 essais sur 1

DIAGRAMME D’ÉTAT

AIDE-MÉMOIRE

Nous avons vu comment définir et manipuler des séquences, leurs composantes et tranches. Pour les listes nous avons aussi vu les méthodes append et extend pour les étendre avec de nouveaux éléments. Python fournit de nombreuses méthodes pour manipuler les trois types de séquences que nous étudions dans ce module.

Dans les capsules vidéo qui suivent nous allons terminer l’étude des séquences de données chaîne de caractères, tuples et listes Python3 et leurs manipulations, en présentant un bon nombre de ces méthodes. Elles vont nous permettre de résoudre de nombreux problèmes.

Pour nous faciliter la tâche dans la conception de nos codes, nous avons confectionné un petit aide mémoire téléchargeable ici résumant l’effet de chacune des fonctions et méthodes présentées ou que nous allons présenter dans la suite de ce cours.

Nous pourrons ainsi décider quelles méthodes peuvent nous aider, et éventuellement si nous devrons écrire d’autres fonctions de manipulation pour résoudre les problèmes soumis.

Note

quand la syntaxe d’une instruction ou expression Python est donnée la méta-notation
"[...]" signifie que cette partie est optionnelle. Ainsi :

s.count(sub [,start [,end]])

signifie que s.count peut avoir un, deux ou trois arguments.

Ainsi :

"Bonjour UpyLaB!".count('o') renvoie 2 (le caractère 'o' est 2 fois dans "Bonjour UpyLaB!")
"Bonjour UpyLaB!".count('o', 3) renvoie 1 (le caractère 'o' est 1 fois dans le texte "Bonjour UpyLaB!"[3:])
"Bonjour UpyLaB!".count('o', 3, 4) renvoie 0 (le caractère 'o' n’est pas dans le texte "Bonjour UpyLaB!"[3:4] (rappelez-vous que dans ce cas, l’indice 4 est non inclus).

Comme pour le manuel de bonnes pratiques, pourquoi ne pas imprimer cet aide mémoire pour toujours l’avoir sous la main quand vous écrirez du code ?

N’hésitez pas à le consulter et à tester par vous-même l’effet de chacune d’elles.

RECHERCHE ET DE COMPTAGE - ZIP ET ENUMERATE

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

MANIPULATION DE CHAÎNES DE CARACTÈRES

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

MANIPULATION DE LISTES

Télécharger la vidéo en qualité : Haute (1080p) / Normale (720p) / Mobile (480p) / UL

TROIS EXEMPLES

Pour digérer la matière vue dans cette section, nous développons ensemble trois exemples qui utilisent méthodes et fonctions prédéfinies sur les chaînes de caractères et listes. A nouveau pour chaque problème, nous vous invitons à écrire une solution. Ensuite, comparez votre solution avec celle proposée pour valider ou trouver d’autres techniques.

NETTOYAGE D’UNE CHAÎNE DE CARACTÈRES

La fonction keep_alnum retourne la chaîne passée en argument, en lui ayant retiré tous les caractères qui ne sont pas des lettres ou des chiffres. Elle utilise un for pour itérer sur chaque caractères et un if qui teste s’il doit être retenu.

def keep_alnum(s):
  """Nettoie s en lui retirant les caractères non alphanumériques."""

  res = ''
  for letter in s:
     if  letter.isalnum():
        res = res + letter
  return res

L’appel :

keep_alnum('he23.?56th')

donne comme résultat :

'he2356th'

Nous verrons à la section 5.7, qu’une version plus compacte et plus simple de keep_alnum peut être définie avec la notion de compréhension de liste.

LISTE DES LETTRES COMMUNES À 2 MOTS

Tout est dans le titre. Voici une proposition de code qui résout le problème:

def in_both(word1, word2):
 """Renvoie la liste des lettres communes aux 2 mots."""

 res=[]
 for letter in word1:
   if letter in word2 and letter not in res:
     res.append(letter)
 return res

Avec cette définition, l’instruction :

print(in_both('pommeees', 'oranges'))

imprime :

['o', 'e', 's']

Ici il faudra attendre le module suivant pour voir une version plus compacte.

LECTURE D'UNE LISTE DE VALEURS (ENTIÈRES)

Une autre version de lecture de liste de valeurs. Ici, la fonction demande à l’utilisateur d’encoder une liste de valeurs entières sur une ou plusieurs lignes, terminée par une ligne vide (touche clavier return sans rien avant), et renvoie la liste des nombres entiers lus.

La méthode split est utilisée pour décortiquer les lignes lues.

def lecture(invite):
  """Lit et renvoie une liste d'entiers.
   Les données peuvent être sur plusieurs lignes.
  """

  res = []
  x = input(invite)
  while x != '':
     decoupe = x.split()
       # liste des parties de x séparées par un/des espace(s) ou tab
     for elem in decoupe:
        res.append(int(elem))
     x = input()
  return res

# utilisation de la fonction lecture
print(lecture("liste d'entiers terminée par une ligne vide : ")) 

Essayez ce code par exemple avec les entrées sur 5 lignes dont la dernière vide :

Passons maintenant à la mise en pratique Upylab avec ou sans méthode !

EXERCICE UPYLAB 5.8 (EXTERNAL RESOURCE)

UPYLAB 5.8

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Veuillez écrire une fonction anagrammes(v, w) qui renvoie la valeur booléene True si les mots v et w sont des anagrammes, c’est-à-dire des mots qui comprennent les mêmes lettres, en même quantité, mais pas nécessairement dans le même ordre. Par exemple, 'marion' et 'romina' sont des anagrammes.

La fonctio renvoie la valeur booléenne False sinon

Notes :

Votre code ne doit pas tester si les mots existent bien dans un quelconque dictionnaire
On suppose que tout mot est anagramme avec lui même
(par exemple: anagrammes('jour', 'jour') renvoie True)

Entrez votre solution :

sans réponse

EXERCICE UPYLAB 5.9 (EXTERNAL RESOURCE)

UPYLAB 5.9

(2 points possibles)

Parcours : vert bleu rouge

Enoncé

Nous vous demandons d’écrire une fonction intersection(v, w) qui calcule l’intersection entre deux chaînes de caractères v et w.

On définit l’intersection de deux mots comme étant la plus grande partie commune à ces deux mots. Par exemple, l’intersection de "programme" et "grammaire" est "gramm", et intersection("salut","rien") renvoie le string vide "", puisqu'aucun caractère n'est commun.

Si plusieurs solutions sont possibles, prenez celle qui est d'indices les plus petits dans v (par exemple intersection("bbaacc", "aabb") renvoie "bb".

Entrez votre solution :

sans réponse

Détails: Écrit par : Richard GAUTHIER; Création : 9 Avril 2019; Mis à jour : 9 Avril 2019; Clics : 9597

Vidéos YouTube

Snt : Les données

MENU DE CE MODULE

LES CHAÎNES DE CARACTÈRES

LES TUPLES ET LES LISTES

TESTS ÉLÉMENTAIRES ET INSTRUCTION FOR

CODIFICATION UTILISÉE PAR PYTHON POUR LES TEXTES

ORD(C)

CHR(V)

TEMPÊTE OU CYCLONE

HISTORIQUE_TEMPETES

CYCLONE_ANNEE

Enoncé

Entrez votre solution :

RASSEMBLER

SÉPARER

Enoncé

Entrez votre solution :

LE PROJET : INFORMATION PRÉLIMINAIRE

PROJET VASARELY (OP ART)

ENONCÉ DU PROJET VASARELY

RELEVÉES DES PLUIES COMME ILLUSTRATION DES SÉQUENCES

PLUIE_1.PY

PLUIE_2.PY

LES TECHNIQUES DE LECTURE ET D’INITIALISATION D’UNE SÉQUENCE

PLUIE_3.PY

Enoncé

Entrez votre solution :

EXERCICE UPYLAB 5.4 (EXTERNAL RESOURCE)

UPYLAB 5.4

Enoncé

Entrez votre solution :

EXERCICE UPYLAB 5.5 (EXTERNAL RESOURCE)

UPYLAB 5.5

Enoncé

Entrez votre solution :

EXERCICE UPYLAB 5.6 (EXTERNAL RESOURCE)

UPYLAB 5.6

Enoncé

Entrez votre solution :

EXERCICE UPYLAB 5.7 (EXTERNAL RESOURCE)

UPYLAB 5.7

Enoncé

Entrez votre solution :

MINI QUIZ SUR LES SÉQUENCES

QUESTION 1 (UN SEUL ESSAI POSSIBLE)

QUESTION 2 (UN SEUL ESSAI POSSIBLE)

QUESTION 3

QUESTION 4

QUESTION 5

DIAGRAMME D’ÉTAT

MINI QUIZ SUR LES SÉQUENCES

QUESTION 1 (UN SEUL ESSAI POSSIBLE)

QUESTION 2 (UN SEUL ESSAI POSSIBLE)

QUESTION 3

QUESTION 4

QUESTION 5

DIAGRAMME D’ÉTAT

AIDE-MÉMOIRE

RECHERCHE ET DE COMPTAGE - ZIP ET ENUMERATE

MANIPULATION DE CHAÎNES DE CARACTÈRES

MANIPULATION DE LISTES

TROIS EXEMPLES

NETTOYAGE D’UNE CHAÎNE DE CARACTÈRES

LISTE DES LETTRES COMMUNES À 2 MOTS

LECTURE D'UNE LISTE DE VALEURS (ENTIÈRES)

Enoncé

Entrez votre solution :

EXERCICE UPYLAB 5.9 (EXTERNAL RESOURCE)

UPYLAB 5.9

Enoncé

Entrez votre solution :