La modélisation financière est une pratique clé dans le domaine...
C’est le cours python numéro 15 de la série des cours d’initiation à python.
À ce stade, nous avons déjà acquis les principales connaissances sur la langue, et je pense qu’il convient de s’arrêter un instant pour consolider ce que nous avons appris. Dans cette longue leçon, nous examinerons certaines applications de la fonctionnalité de base de Python et présenterons quelques nouvelles fonctionnalités ici et là. Vous pouvez passer aux leçons suivantes même sans réaliser immédiatement tous les exemples que je propose ici ; parfois, cependant, nous nous y référerons plus tard pour les modifier en introduisant de nouvelles fonctionnalités.
En informatique, nous aurons souvent le problème de représenter une situation réelle à travers un programme. Cela signifie que nous devons choisir les structures de données appropriées, qui contiennent les informations que nous devons connaître, et les fonctions appropriées qui opèrent sur ces données pour obtenir les résultats souhaités. Un programme d’une certaine complexité nécessite donc une phase de conception, qui consiste essentiellement à analyser les informations qu’il faudra connaître et la manière dont le programme doit manipuler ces informations, puis à traduire tout cela en éléments du langage (variables et fonctions ).
Voyons un exemple simple : nous voulons représenter un jeu de cartes, qui pourra ensuite être utilisé pour simuler des jeux. Analysons d’abord les informations que nous devons connaître :
Voyons ensuite les opérations que nous pouvons effectuer sur le pont :
Voici une solution à notre problème :
NOUVEAU PROGRAMME : pack_cards.py
Importez le module random et initialisez le générateur de nombres aléatoires (voir ici)
Copiez ces listes dans le programme :
costumes = [“pièces”, “tasses”, “épées”, “bâtons”]
valeurs = [“as”, “deux”, “trois”, “quatre”, “cinq”, “six”, “sept”, “valet”, “chevalier”, “roi”]
Créer la liste des cartes (en utilisant la fonction range () puis en convertissant la plage en liste)
Mélangez le jeu en appelant la fonction shuffle() avec la liste comme argument : une fois appelés, les numéros seront triés au hasard
Pour piocher une carte, écrivez c = carte.pop() (pioche la dernière carte du jeu et l’affecte à la variable c)
Attribuez à la variable s le premier chiffre de c (la graine, de 0 à 3) et à la variable val le second (la valeur, de 0 à 9 : ce n’est pas grave car il faut l’utiliser comme index dans une liste)
A ce point dans suits [s] il y a la couleur de notre carte et dans values [val] il y a la valeur : print
as de coupe (ou trois d’épées etc.)
Nous voulons maintenant tirer plus de cartes à la suite, comme dans un jeu de cartes. La méthode la plus simple consiste à insérer les étapes 5 – 6 – 7 du programme dans une boucle for i in range (40) : qui va alors extraire toutes les cartes du jeu (essayez).
Mais on veut être un peu plus raffiné, et laisser l’utilisateur extraire la carte en appuyant sur Entrée : on va imprimer un message du genre “Appuyez sur q pour sortir, Entrée pour extraire une carte” puis on lui montrera la carte de sortie. Entre autres choses, puisque l’utilisateur ne sait pas combien de cartes restent dans le jeu, nous devrons également gérer la possibilité qu’il soit vidé : dans ce cas (comme cela se fait dans de nombreux jeux) nous rebattrons les cartes et recommencerons . Modifiez le programme comme suit :
Les deux premières étapes sont comme dans le programme précédent
Définir la liste des cartes initialement vides (nous la “remplirons” dans le cycle principal, à chaque fois que nous devons rebattre le paquet)
Entrez maintenant dans une boucle while sans fin (voir ici)
Avec une entrée () imprimez le message pour l’utilisateur et prenez la chaîne resp
Si resp est égal à “q” quitter le while immédiatement (revoir la Leçon 9), sinon…
Avant de tirer une carte, vous devez vérifier si le jeu est vide (vérifiez simplement si la longueur de la liste est 0). Dans ce cas, entrez les étapes 3 à 4 du programme précédent. Avertissez l’utilisateur en imprimant “Veuillez patienter : je mélange le jeu…”
Vous pouvez maintenant continuer avec les étapes 5 à 7 du programme précédent (toujours à l’intérieur de la boucle while)
Enfin, en dehors de ce moment, il salue l’utilisateur pour confirmer que le programme est terminé
Voici un exemple d’E/S :
Appuyez sur q pour quitter, Entrée pour piocher une carte
Attendez : je mélange les cartes…
as de carreau
Appuyez sur q pour quitter, Entrée pour piocher une carte
valet d’épée
Appuyez sur q pour quitter, Entrée pour piocher une carte
valet de tasses
Appuyez sur q pour quitter, Entrée pour piocher une carte q
Fin du programme
Enfin, après cet exercice, vous pouvez utiliser le jeu de cartes dans le jeu Banco.py que nous avons déjà programmé ici : vous devez modifier quelque chose à la fois dans le programme original et dans celui qui vient d’être écrit, je vous le laisse comme un exercice.
Lorsque nous avons introduit les chaînes, nous avons dit qu’il existe trois syntaxes différentes pour définir une chaîne : “mom”, ‘mom’, “” “mom” “”. Alors que les deux premiers sont équivalents, le troisième vous permet d’envelopper la définition de la chaîne, même en laissant des espaces blancs en tête dans les lignes suivantes. Dans IDLE, vous pouvez diviser l’instruction en plusieurs lignes : après avoir écrit la première ligne, appuyez sur Entrée, et vous verrez qu’IDLE ne vous répondra pas mais vous renverra simplement ; la réponse ne viendra que lorsque vous appuyez sur Entrée après avoir fermé les trois guillemets.
>>> print ("""1
2
3
4""")
1
2
3
4
En fait, il n’est pas vraiment facile d’interpréter cette (unique) affirmation. Dans la première ligne, il y a la fonction print(), les parenthèses et les triples guillemets ouverts ; il y a aussi le premier caractère de la chaîne à imprimer : “1”. Maintenant, la chaîne continue dans les lignes ci-dessous allant jusqu’à la tête et se termine à la quatrième ligne avec les triples guillemets et la parenthèse fermante (les quatre autres lignes sont la réponse de IDLE); notez que les espaces à gauche dans les lignes suivantes font partie de la chaîne et sont imprimés. Voici un autre exemple :
>>> print(""" CCCCC II AAAAAA OOOOOO CC II AA AA OO OO CC II AA AA OO OO CC II AAAAAA OO OO CCCCC II AA AA OOOOOO""")CCCCC II AAAAAA OOOOOO CC II AA AA OO OO CC II AA AA OO OO CC II AAAAAA OO OO CCCCC II AA AA OOOOOO
ici j’ai une nouvelle ligne juste après le “” ” : cela signifie que la chaîne commence par une nouvelle ligne (notez la ligne vide entre l’instruction et la réponse). Je me souviens de deux choses :
Dans IDLE vous devez obligatoirement insérer la chaîne dans une instruction print() : si vous n’écrivez que le nom de la chaîne IDLE vous montrera les sauts de ligne avec la séquence d’échappement “\n”
C’est précisément pour cette raison que la première ligne de la chaîne est généralement “décalée” des autres et cela peut être gênant lorsque nous tapons notre création (notez la différence entre le premier et le deuxième exemple). Dans le second cas, il est plus facile d’insérer la chaîne, mais cela laissera une ligne vide au début.
PPPPPP AAAAAA CCCCCC MM MM AAAAAA NN NN
PP PP AA AA CC MMM MMM AA AA NNN NN
PPPPPP AA AA CC MMMMMMM AA AA NNNN NN
PP AAAAAA CC MM M MM AAAAAA NN NNNN
PP AA AA CCCCCC MM MM AA AA NN NN
Les boucles For peuvent également être utilisées pour obtenir des dessins.
NOUVEAU PROGRAMME : ciclo_artistici.py
Essayons d’abord ce petit programme simple qui utilise la multiplication d’une chaîne par un nombre (sa sortie est montrée ci-dessous)
for i in range(1, 11): # i da 1 a 10
print(i * "*")
* ** *** **** ***** ****** ******* ******** ********* **********
Nous voulons maintenant obtenir cette sortie :
1 22 333 4444 55555 666666 7777777 88888888 999999999
On pourrait être tenté d’écrire ceci :
for i in range(1, 10): # i da 1 a 9
print(i * i)
mais si nous essayons, nous obtiendrons une série de nombres, car dans la deuxième ligne, Python multiplie deux nombres ensemble. On a besoin de la fonction str() qui est un peu l’inverse de int() et float(), c’est à dire qu’elle transforme, par exemple, le nombre 10 en la chaîne “10”
for i in range(1, 10): # 1 da 1 a 9
print(i * str(i))
Comment pourriez-vous obtenir même une ligne avec 10 zéros ? Écrire simplement pour i dans l’intervalle (1, 11) n’est pas bon car quand i devient 10… Il suffit d’écrire le dernier chiffre du nombre : c’est le même problème que nous avons rencontré dans le jeu de cartes.
Enfin, une technique un peu plus raffinée consiste à écrire deux boucles for l’une dans l’autre (imbriquées) : dans la boucle externe (avec le compteur i) on définit une chaîne vide s, après quoi on utilise une autre boucle interne (avec j) pour ajouter des caractères à la chaîne les uns après les autres. Après avoir quitté la boucle interne, nous imprimerons la chaîne (vous pourriez être tenté d’imprimer les caractères directement dans la boucle interne, mais vous devez vous rappeler que print () s’enroule à chaque fois qu’il est appelé, nous ne pouvons donc imprimer qu’une seule ligne à la fois temps). Essayez de comprendre (éventuellement avec le débogueur) comment ce programme obtient la sortie :
for i in range(1, 11):
s = ""
for j in range(1, 11):
if j == i or j == 11 - i:
s += "+"
else:
s += "."
print(s)
+........+ .+......+. ..+....+.. ...+..+... ....++.... ....++.... ...+..+... ..+....+.. .+......+. +........+
Essayez d’obtenir ces sorties vous-même (pour simplifier je les ai regroupées sur deux lignes, chaque figure est un exercice séparé). Gardez à l’esprit qu’il existe de nombreuses façons d’obtenir le même résultat (cependant vous pouvez obtenir tous les chiffres facilement en utilisant une seule boucle), il est important cependant que le nombre de caractères imprimés corresponde exactement au motif (s’il y a une ligne ou un caractère plus ou moins bien vérifier les indices de vos gammes ())
L’introduction de l’ordinateur dans le calcul mathématique a rendu de nombreuses procédures extrêmement simples qui nécessitaient autrefois des calculs très lourds, longs et compliqués même avec une simple calculatrice. En particulier, un algorithme itératif est une procédure qui tente d’atteindre un certain résultat en s’en rapprochant de plus en plus avec différents tests : il part d’une valeur de test initiale, évalue l’erreur qui a été commise et recherche une nouvelle valeur de try “plus proche” du résultat que vous recherchez. En répétant la procédure, vous vous rapprochez de plus en plus jusqu’à ce que vous atteigniez la précision souhaitée.
Un exemple simple est le soi-disant “algorithme babylonien” pour le calcul de la racine carrée (pour une discussion détaillée, voir Wikipedia). Supposons que nous ayons besoin de trouver la racine carrée d’un nombre n : cela équivaut à « deviner » le côté d’un carré d’aire n. Essayons d’abord avec un rectangle de base b choisi au hasard (par exemple b = 1) : en divisant h = n / b on trouve la hauteur h du rectangle. Maintenant, si b == h on a trouvé la racine (le rectangle est un carré), si b> h on a choisi b trop grand et si b <h on l’a choisi trop petit : donc la vraie racine est un nombre compris entre b et h. Il suffit donc de prendre b = (b + h) / 2 (la moyenne entre b et h) comme nouvelle base : ce nombre est certainement plus proche de la racine que l’on recherche. En itérant cette procédure on obtient une succession de nombres b1, b2, b3, … qui se rapprochent de plus en plus de notre racine carrée (en mathématiques on parle de succession convergente).
Dans ce type d’algorithme, une boucle while est généralement utilisée, car on ne sait pas a priori combien de fois la procédure doit être répétée. Pour comprendre comment nous devrons définir la condition de contrôle, il faut considérer que dans le calcul scientifique l’égalité entre deux nombres flottants (c’est-à-dire avec une virgule) n’est jamais testée avec l’opérateur ==, car l’ordinateur effectue toujours des calculs approximatifs (même si avec un très grand nombre de décimales) : ces calculs peuvent conduire à des erreurs d’arrondi et donc les nombres pourraient être différents même si théoriquement ils devraient être les mêmes (ou inversement). Ainsi deux nombres flottants a et b sont considérés comme “égaux” si leur distance abs (a – b) (la valeur absolue de a – b) est très petite (traditionnellement en mathématiques la lettre grecque ε (epsilon) est utilisée pour indiquer un positif nombre très petit).
Alors écrivons un programme qui trouve la racine carrée d’un nombre ; nous y insérerons également l’impression de tous les résultats intermédiaires, pour mieux “voir” notre algorithme au travail.
NOUVEAU PROGRAMME : root.py
Vous avez demandé la main de la fille du Roi, mais le père, avant de l’accorder, vous a soumis à une cruelle épreuve. Vous êtes au centre d’un labyrinthe et dix fois vous devrez choisir entre une porte à gauche et une à droite : si vous ouvrez celle de droite vous pouvez continuer, mais si vous vous trompez vous trouverez un monstre qui vous tuera.
Dans le jeu, nous devrons alors deviner une chaîne aléatoire de 10 caractères “s” ou “d” (par exemple “ssdsddsdds” ou “dddssdssdd”) en tapant un caractère à la fois. Chaque fois que nous nous tromperons, nous devrons recommencer (et donc mémoriser tous les caractères corrects déjà saisis). Pour le rendre plus drôle à chaque fois que nous mourrons, nous essaierons de simuler un minimum de graphismes avec une chaîne “artistique” comme ceux que nous avons déjà vus.
Dans la première partie du programme, nous initialiserons les variables dont nous avons besoin et donnerons les instructions nécessaires à l’utilisateur, puis nous devrons programmer le jeu proprement dit.
Comme d'habitude, importez le module random et initialisez le générateur de nombres aléatoires Copiez ce code dans le programme chaîne_début = "" " Vous êtes emprisonné dans un labyrinthe. 10 fois vous devrez ouvrir une porte à gauche ou une à droite. Si vous faites une erreur, vous MOURREZ ! Appuyez sur ENTER lorsque vous êtes prêt "" " chaîne_mort = "" " AAAARRRRGGGGHHHH ! TU ES MORT! ## ###### ## ## ## Mais heureusement, vous pouvez recommencer ! "" " En savoir plus sur ce texte source
Il faut s’attarder un peu sur l’étape 2, pour souligner encore une fois combien les programmeurs détestent insérer des constantes (chiffres et chaînes) pendant le programme : ces chaînes pourraient facilement être écrites aux points où nous devons les imprimer (par exemple : print (“” “Vous êtes emprisonné…), mais cela conduirait à une mauvaise lisibilité (les chaînes s’étendent sur plusieurs lignes et il serait même difficile de comprendre quelle est l’instruction suivante). Vous préférez alors affecter leur valeur à un puis écrivez print (start_string) qui est beaucoup plus facile à lire. De plus, en initialisant toutes ces variables ensemble dans la première partie du programme, il est plus facile de les retrouver si nous décidons de les modifier (par exemple, vous pouvez remplacer ma death_string par votre propre création).
Créer une chaîne de port initialement vide En utilisant une boucle for, vous concaténez à la chaîne (avec l'opérateur + =) dix chaînes aléatoires "s" ou "d". ATTENTION : pour créer une chaîne qui est aléatoirement "s" ou "d" il existe plusieurs techniques différentes. Passez en revue les fonctions du module aléatoire ici) Insérez maintenant l'entrée d'instruction (start_string) qui imprimera l'explication du jeu et attendez que vous appuyiez sur Entrée : notez que dans ce cas, il n'est pas nécessaire d'affecter la valeur renvoyée à une variable
À ce stade, comme nous l’avons vu dans le programme guess_numero.py, nous pouvons également insérer la gestion des enregistrements, que je vous laisse.
Reprenons l’exemple que nous avons fait au début de la leçon 11. Nous avons souligné que pour résoudre de nombreux problèmes, l’utilisation de types de données complexes, formés par l’agrégation de plusieurs données atomiques, est naturelle. Les langages de programmation ont répondu à ce besoin avec la Programmation Orientée Objet (POO), qui est pourtant un sujet assez avancé et que nous n’aborderons pas ici. Nous nous limiterons ici à montrer l’utilisation de listes de listes (c’est-à-dire de listes dont les éléments sont à leur tour des listes).
Imaginons avoir à écrire un programme qui gère la note finale d’une classe : la classe sera composée de plusieurs élèves et chacun aura ses notes. Pour simplifier au maximum nous ferons les hypothèses suivantes :
Pour chaque élève nous ne mémoriserons que le nom et le prénom
Nous n’aurons que deux matières: italien et mathématiques
L’élève sera promu s’il a reçu deux laissez-passer, renvoyé avec une insuffisance et échoué avec deux insuffisances
Passons à la représentation des données : on peut représenter un étudiant avec une liste de cinq éléments :
| index dans la liste | signification | Type de données |
| 0 | nom | str (stringa) |
| 1 | Prénom | str |
| 2 | voter en italien | int (numero intero) |
| 3 | voter en mathématiques | int |
| 4 | résultat du scrutin | str (“p”, “r” o “b”) |
Ainsi, si a est un élève, un [0] sera son nom de famille, un [1] son nom, et ainsi de suite. La classe sera alors une liste d’élèves (et donc, comme nous l’avons dit, une liste de listes). Alors, comment lit-on la note en italien du deuxième élève de la classe ? La syntaxe est très simple, et ressemble à celle utilisée en Mathématiques : le deuxième élève est l’élément d’indice 1 de la classe, et sa note en italien est l’élément d’indice 2 de l’élève. Nous devrons donc écrire la classe [1] [2] (c’est-à-dire l’élément 2 de l’élément 1 de la classe). S’il vous semble que tout cela est trop compliqué, essayez de vous entraîner avec IDLE.
class = [[“Abbotti”, “Cesare”, 5, 6, “r”], [“Bombetti”, “Camilla”, 9, 10, “p”],
[“Casini”, “Piergiorgio”, 4, 3, “b”], [“De Rompis”, “Anna”, 7, 5, “r”]]
Notez l’utilisation de crochets les uns à l’intérieur des autres pour indiquer que les éléments de la liste de classe sont eux-mêmes des listes. Essayez maintenant de donner les commandes suivantes (j’ai omis la sortie) en essayant de deviner le résultat avant d’appuyer sur Entrée :
classe [0] [0]
classe [0] [1]
classe [1] [0]
classe [1] [1]
classe [2] [2]
classe [2] [3]
classe [4] [4]
Voici maintenant un programme qui nous permet d’entrer le nom, le prénom et les notes de chaque élève; délibérément, pour le moment, on néglige le résultat du scrutin (vous le ferez en exercice)
sujets = ["Italien", "Mathématiques"]
class = [] # notre classe, initialement vide
resp = "s"
while resp == "s": # boucle pour insérer les pupilles
élève = []
print ("Student", len (classe) + 1) # imprime le numéro de l'étudiant actuel
alunno.append (input ("Insert last name")) # plus compact, sans utiliser de variables intermédiaires
alunno.append (entrée ("Entrez le nom"))
for i in range (len (sujets)): # d'habitude, on n'écrit pas range (2)
alunno.append (int (input ("Insérer la note dans" + matières [i] + "")))
class.append (élève) # ajoute l'élève à la classe
resp = input ("Voulez-vous insérer un autre étudiant ? (o/n)") Maintenant, nous voulons imprimer un résumé des notes de chaque élève : utilisez une boucle avec le compteur i que vous itérez sur les indices de la liste de classe pour obtenir une sortie similaire à celle-ci :
1 Abbotti Cesare Italiano 6 Mathématiques 5
2 Bombetti Camilla Italiano 9 Mathématiques 10
…
ATTENTION : L’obtention de cette sortie n’est pas aisée : il faut utiliser des index doubles pour se référer aux données des élèves simples et le caractère de tabulation “\t” pour aligner les différents mots. Malheureusement, si vous introduisez des noms longs et des noms courts (par exemple “Ugo” et “Alessandro”), la tabulation ne s’alignera pas correctement, ce qui vous donnera un résultat esthétiquement moche. Comme je l’ai dit, il existe des instructions Python pour formater les chaînes mais nous n’en parlerons pas pour l’instant. Il peut aussi être utile, au lieu d’écrire un print() très compliqué, d’utiliser une variable intermédiaire s à construire en ajoutant progressivement les différentes données.
Voyons enfin comment résoudre le problème du résultat du scrutin : ces données ne doivent pas être saisies par l’utilisateur mais doivent être obtenues à partir du programme lui-même.
Le commentaire composé est un exercice littéraire qui consiste à analyser un texte en respectant…
Les adjectifs liés en français sont les adjectifs qui s’accordent en genre (masculin/féminin) et en…
Voici une liste étendue de mots piégeux en français, avec leurs genres et des explications…
Apprendre à distinguer le genre des noms en français peut être un véritable défi pour…
1. Informations Générales Nom complet : Charles-Louis de Secondat, Baron de La Brède et de…
Introduction L’Art de la Guerre (Dell’arte della guerra), publié en 1521, est l’un des ouvrages…
This website uses cookies.