Mon projet Python par Nathan

Travail de Nathan

Ce projet réalisé par Nathan, élève de 3ème au collège C Peguy d’Arras a été réalisé dans le cadre d’une formation en programmation (algorithme)

Au cycle 4, les élèves s’initient à la programmation, en développant dans une démarche de projet quelques programmes simples, sans viser une connaissance experte et exhaustive d’un langage ou d’un logiciel particulier. En créant un programme, ils développent des méthodes de programmation, revisitent les notions de variables et de fonctions sous une forme différente, et s’entraînent au raisonnement

Code Python traduit en HTML:
# nathan m. 3B octogone
from turtle import *
speed("fastest" )
shape("blank" )#cela enlève le curseur
title("mon projet Nathan 3B" )
# une boucle de 500 itérations
for i in range(500):
    bgcolor("black" )
    color("pink" )# je change de couleur a chaque fois
    forward(500-i)
    right(190)
    color("blue" )
    forward(500-i)#on avance
    right(190)#on tourne a droite
    color("green" )
    forward(500-i)
    right(190)
    color("purple" )
    forward(500-i)
    right(190)
    color("red" )
    forward(500-i)
    right(190)
    color("yellow" )
    forward(500-i)
    right(190)
    color("white" )
    forward(500-i)
    right(190)
    color("orange" )
    forward(500-i)
    right(190)
    width(5) #on épaisie le trait 

Mes commentaires

Quand on débute dans un langage de programmation, commenter ses sources a une importance particulière : aider à mémoriser les instructions simples. Mais Python est tellement « lisible » que la plupart des commentaires sont ici inutiles. 

Le résultat est simple et joli, et je ne me suis posé qu’une question à la lecture du code : Pourquoi 500 itérations ?

Quand tu écris right(190) tu tournes à droite ???

Un lexique genre ODS7 en txt…

Cet article est obsolète, vous pouvez lire l’ Article mis à jour pour l’ODS8

L’Officiel du Scrabble® est le dictionnaire officiel du jeu de Scrabble® francophone depuis le 1er janvier 1990. Il est édité par Larousse et est couramment appelé « ODS » par les scrabbleurs.

2016 voit l’entrée en vigueur de l’ODS7…

Sur le site de la fédération on peut lire :

Qui contacter pour distribuer/vendre un ouvrage ou autre produit utilisant la base de mots de l’Officiel du Scrabble® ?

Tout auteur souhaitant distribuer/vendre un ouvrage ou autre produit (hors application pour Smartphone), utilisant une base de mots conforme à l’Officiel du Scrabble®, doit remplir un contrat de partenariat qui lui sera envoyé sur demande faite auprès de la FISF, à l’adresse suivante : contact@fisf.net

Toute société souhaitant distribuer/vendre un produit numérique privé/grand public sécurisé du type application pour Smartphone, utilisant une base de mots conforme à l’ODS, doit contacter Jean-François Richez, responsable des licences numériques chez Larousse, à l’adresse suivante : JFRICHEZ@larousse.fr

Voilà, mais pour des besoins pédagogiques (formation algorithme au cycle 4) j’avais besoin d’une liste de mots en .txt

Remarque : Je dis bien liste de mots (et non dictionnaire). Et les mots sont à tout le monde…

En effet j’envisage de faire travailler des élèves de 4ème, 3ème sur le développement d’algorithmes divers ayant pour base des jeux de lettres :

  • Boggle
  • Scabble
  • Pendu
  • etc…

Après quelques recherches sur la toile, je me suis aperçu que le fichier txt que je cherchais n’existait pas. Mais que quelques sites proposaient des listes (en html multi-pages. )

Ainsi le très bon listesdemots.net vous propose de nombreuses liste de mots. (898 pages)

Il était donc possible mais fastidieux de créer un fichier txt en copiant collant toutes ces listes !

Pas si fastidieux si on a Python sous le coude !

#wouf 2018 (py3.6.4)
#http://site2wouf.fr
#Pour créer dico.txt
#Qui contient un lexique basé sur
#ODS7
#En scollant le site : listesdemots.net
#requis :l beautifulsoup4
#(cmd : pip install beautifulsoup4)

import requests
from bs4 import BeautifulSoup
fichier = open("dico.txt", "w")

#	Initialisation:
url="https://www.listesdemots.net/touslesmots"
requete = requests.get(str(url+".htm")) #page1
print(requete.url)
page = requete.content

soup = BeautifulSoup(page,features="html5lib")
span = soup.find("span", {"class": "mot"})
mots=span.string.strip()
lesmots=mots.split(" ")
for l in lesmots:
    fichier.write(l+"\n")
    print("|",end="")
print()
print("page 1 : OK ("+str(len(lesmots))+")")
totalmot=len(lesmots)
fichier.close()
#page 2 à 8998:
for i in range(2,899):
    fichier = open("dico.txt", "a")
    lurl=url+"page"+str(i)+".htm"
    ok=False
    while not ok:
        try:
            requete = requests.get(lurl,timeout=1)
            ok=True
        except:
            print("Problème de connexion. Je recommence !")
    print(requete.url)
    page = requete.content
    soup = BeautifulSoup(page,features="html5lib")
    span = soup.find("span", {"class": "mot"})
    mots=span.string.strip()
    lesmots=mots.split(" ")
    for l in lesmots:
        fichier.write(l+"\n")
        print("|",end="")
    totalmot+=len(lesmots)
    print()
    print("page "+str(i)+" : OK ("+str(len(lesmots))+"/"+str(totalmot)+")")
    fichier.close()
#fin du scipt:
 

print("mots :",totalmot)
    


Ce script produit en quelques minutes un fichier txt (avec un mot par ligne) contenant les 402 503 mots du site !

En cas de mauvaise connexion, pas de souci, le script gère ! Le temps de génération du fichier txt sera sensiblement plus long !

Enjoy !

Mon projet Python, par Nolan

Travail de Nolan

Ce projet réalisé par Nolan, élève de 3ème au collège C Peguy d’Arras a été réalisé dans le cadre d’une formation en programmation (algorithme)

Au cycle 4, les élèves s’initient à la programmation, en développant dans une démarche de projet quelques programmes simples, sans viser une connaissance experte et exhaustive d’un langage ou d’un logiciel particulier. En créant un programme, ils développent des méthodes de programmation, revisitent les notions de variables et de fonctions sous une forme différente, et s’entraînent au raisonnement

Code Python traduit en HTML:
#Nolan L. 3B
from turtle import*
title("Mon projet python Nolan" )
bgcolor("black" )#Je change de couleur l'arrière plan
speed("fastest" )#La vitesse
shape("blank" ) #Faire disparaître le curseur
for i in range(125):

    color("red" )
    forward(100+i)#A chaque fois, il augmente de +1
    left(90)
    color("green" )
    forward(100)
    left(90) #Il tourne à gauche
    color("blue" )
    forward(100)
    left(90)
    color("yellow" )
    forward(100)
    up() #Je lève le crayon
    forward(10)
    down()#Je remet le crayon
            

Mes commentaires

Quand on débute dans un langage de programmation, commenter ses sources a une importance particulière : aider à mémoriser les instructions simples. Mais Python est tellement "lisible" que la plupart des commentaires sont ici inutiles. 

Le résultat est simple et joli, et je ne me suis posé qu'une question à la lecture du code : Pourquoi 125 itérations ?

Mathématiques et Paris sportifs

Rugby player

-« A quoi servent les Mathématiques ? »

-« A comprendre la vie ! »

Les paris sportifs sont à la mode depuis un certain temps. Passion pour certains, moyen d’arrondir les fin de mois pour d’autres, ils sont souvent abordés sans une connaissance mathématique préalable …

En effet même si une bonne connaissance footballistique peut s’avérer nécessaire pour parier sur le foot, elle n’est pas suffisante pour parier intelligemment.

I. Définition du TRJ.

Le TRJ est défini comme : la proportion des sommes gagnées par le(s) joueur(s) par rapport à la totalité de leur(s) mises ou dépenses (droit d’inscription par exemple pour les tournois de poker), pour une période de temps donné c’est-à-dire le pourcentage des mises des joueurs Taux de retour au joueur (TRJ),
redistribué aux joueurs sous forme de gain. Il s’agit donc bien de la masse d’argent qui ne revient ni à l’opérateur ni aux pouvoirs publics mais aux joueurs.

II. Législation.

En France, depuis la loi de mai 2010 et à la différence de la plupart des Etats, le TRJ est plafonné à une moyenne de 85% calculée sur deux trimestres consécutifs.

III. Un exemple détaillé.

Mettons nous à la place d’un bookmaker d’un site de paris en France. Monsieur Six va gagner son match de dés contre monsieur Un_ou_deux avec une probabilité de 1/6 (soit environ 0,17), il perdra 2 fois sur 6  (environ 0,33) et fera match nul le reste du temps 3/6=0.5…

Les cotes (1N2) devraient être

  • 1:      6 contre 1
  • N:     2 contre 1
  • 2:      3 contre 1

Un joueur lambda qui a misé 1€ sur le résultat 1 gagnera 6€ une fois sur 6 et perdra 5 fois sur 6. En moyenne sur 6 jeux ils remboursera sa mise de 6€. On dit que son espérance de gain est 1 (pour 1).

Un autre joueur qui a misé sur le N 1 € gagnera 2 € une fois sur 2. En moyenne il remboursera sa mise de 2 € tous les 2 jeux…

Un troisième joueur qui a misé sur 2 ne gagnera que 2 fois sur 6  : 3€. Je vous laisse vous convaincre que son espérance de gain est encore 1.

Le bookmaker redistribuera donc en moyenne donc toutes les mises, soit 100% et sera hors la loi !

vacances aout 2008

Diminuons chaque cote pour ne distribuer que 85% comme il est préconisé :

  • 1:      6 x 85/100 = 5.1
  • N:     2 x 85/100 = 1.7
  • 2:      3 x 85/100 = 2.55

Le résultat le plus probable est toujours le match nul mais que se passe-t-il si on mise à présent sur ce résultat :

1 fois sur deux on gagnera 1.7€, une fois sur 2 on perdra 1€…

On perdra en moyenne 0,30 tous les deux euros investis, soit 0.15€ pour chaque euro investi ! (Espérance de gain : 0.85)

Il semble donc que le joueur soit condamné à perdre…

IV. Et pourtant…

Nous connaissons tous, un Raymond, un Gilbert ou un Gérard, vieux joueur de PMU à la réputation, fondée, d’être un joueur gagnant. Vous l’avez sans doute entendu maugréer  une phrase du genre:

– » Avec l’effet Abrivard, on passe à moins de 2 contre 1 j’ai plus la cote… »

C’est incontestablement la fin de sa phrase qui donne la piste à suivre !

Avoir la cote :  Le mot ‘cote’ est une des nombreuses preuves qu’en français, un simple circonflexe peut changer complètement le sens d’un mot.
En effet, il n’est point ici question de la côte de porc ou de la course de côtes, mais de la ‘cote’ au sens d’appréciation, de note, de valeur, comme on le trouve dans la « cote d’alerte », la « cote mobilière » ou la cote d’une action en bourse, par exemple.

Ici, c’est le sens d’appréciation qui est retenu, quelqu’un qui a la cote étant quelqu’un de très apprécié car, bien que l’expression ne contienne aucun adjectif, la ‘cote’ est implicitement élevée. 

Quand Gilbert dit ici qu’il n’a plus la cote il veut dire qu’il n’a plus la cote suffisante pour investir…

On peut supposer qu’il voulait jouer un cheval gagnant, et qu’il avait une bonne chance de remporter l’épreuve. Si le fait que la cote passe sous les 2/1 l’inquiète c’est qu’il envisageait la probabilité que son cheval gagne aux environs de 0.5 (une fois sur 2)

Ce joueur a compris que quand on parie, l’adversaire n’est pas autrui (l’autre joueur) mais la cote !

poker

V. Quand jouer ?

A Le Surebet

Un surebet, littéralement un pari certain, est un événement rare qui permet au parieur d’empocher de façon certaine un peu d’argent.

Imaginons un match de tennis entre John Doe (côté à 1.8/1) et Paul Smith (côté à 3.6/1). Savez-vous qu’il est possible de gagner de façon certaine ?

Si on joue 2€ à 1.8/1 et 1€ à 3.6/1 on dépense 3€… Si John l’emporte on gagne 2×1.8=3.6 € pour un bénéfice net de 0.60€. Si par contre il perd, Paul l’emporte, on empoche 3.6€ pour un bénéfice de 0.60€

Ainsi le bénéfice minimum est de 0.60€ pour un investissement de 3€ soit 20% du capital investi et ce sans aucune connaissance en Tennis !

Comment pouvait-on se rendre compte que ce surebet était possible ?

On a vu précédemment que les bookmakers diminuaient les cotes pour respecter les 85% maximum de TRJ. La probabilité étant l’inverse de la cote, il faut s’attendre, en ajoutant les probabilités à dépasser sensiblement 1 !

Ici on trouve environ 0,83 : Le surebet est possible !

J’ai créé une petite application gratuite (en Python) qui permet non seulement de détecter les éventuels Surebet mais qui indique aussi la meilleure rentabilité en terme de mise : aide_aux_paris.py

B. Le value Bet

Beaucoup plus fréquent que le surebet est le valuebet. Il s’agit d’un pari, pas toujours gagnant (donc risqué au sens probabiliste) mais rentable : Il s’appuie sur une erreur de cotation des bookmakers.

Exemple :

Cette image est extraite du très pratique cotes.fr dont la vocation est de comparer les cotes de différents sites de paris sportifs.

Avec une calculatrice calculez 1/1.08… Vous trouverez environ 0,93. Si vous pensez que Rafael Nadal à une probabilité de l’emporter supérieur à 93% vous devez miser sur lui, sinon définitivement vous abstenir !

Mais attention, des spécialistes avaient évalué cette proba à 0.85/1.08 soit environ 79%. Etes vous meilleurs qu’eux en connaissances tennistique .?

Avec  aide_aux_paris.py en saisissant les cotes on obtient :


Le soft vous donne de nombreuses informations :

  • Les modifications de cotes pour rendre le surebet possible.
  • Les cotes en valuebet minimum (qui gomment le TRJ)

Plus d’informations sur ce logiciel d’aide aux paris sportifs gratuit.

En cadeau, et en guise de conclusion

Pour les jeux d’incertitude, jeux ou le hasard tient une place importante (Paris sportifs, courses hippiques, poker etc.) , je conseille d’avoir en mémoire, ou sous les yeux le rapport entre cote et probabilités:

Vous pouvez télécharger et imprimer ce document en PDF.

LIENS CONNEXES :

Python vers html

L’algorithme au collège st une nouveauté intéressante. Nous sommes au début d’une ère nouvelle où les têtes pensantes hésitent encore sur les outils à utiliser.

Si d’aucun ne jure que par scratch ou algobox d’autres, comme moi ont le coeur qui bât pour Python.

Le premier souci que nous pouvons rencontrer est la publication d’algorithme (code) sous les ENT, sites perso ou blog…

Code Python traduit en HTML:

print("Bonjour monde"  )
mavariable=input()

Un tel programme Python posté en texte donnerait :

print(« Bonjour monde » )

mavariable=input()

J ai développé une petite application qui transforme un code Python en HTML

Plus d’informations

Poker : courbe en cloche et attitude face à la malchance

chimie

La courbe en cloche ou courbe de Gauss est l’une des courbes mathématiques les plus célèbres. On la voit apparaître dans un grand nombre de situations concrètes — en statistiques et en probabilités — et on lui fait souvent dire tout et n’importe quoi.(1)

Pour en savoir plus sur cette courbe, je vous conseille cette petite vidéo :

Tous les joueurs de Poker sont confrontés à la variance. Pour certain c’est une justification, un genre d’excuse pour s’autoriser à jouer mal. Pour d’autres c’est l’ennemi, qui les effrayent et les conduit au tilt. Faut-il en tenir compte ou faut-il l’ignorer ?

Une vérité mathématique : c’est à long terme que la fréquence s’approche de la probabilité.

J’ai simulé sous Python le lancée d’une pièce 100 millions de fois :

import random

s=0
for i in range(1,100000001):
    r=random.randint(0,1)
    s=s+r
    if (i%10000000==0):
        print ("lancees :",i,"piles :",s,"frequence :",s/i)

Le résultat est classique :

>>> ================================ RESTART ================================
>>> 
lancees : 10000000 piles : 4998747 frequence : 0.4998747
lancees : 20000000 piles : 10001071 frequence : 0.50005355
lancees : 30000000 piles : 15000402 frequence : 0.5000134
lancees : 40000000 piles : 20001787 frequence : 0.500044675
lancees : 50000000 piles : 24998410 frequence : 0.4999682
lancees : 60000000 piles : 29996608 frequence : 0.49994346666666667
lancees : 70000000 piles : 34999458 frequence : 0.49999225714285717
lancees : 80000000 piles : 39997336 frequence : 0.4999667
lancees : 90000000 piles : 44998925 frequence : 0.49998805555555553
lancees : 100000000 piles : 50001889 frequence : 0.50001889

La fréquence de pile s’approche de la fréquence théorique de 0,5, qui est appelée probabilité de l’événement « La pièce tombe sur pile« 

Mais abandonnons la pièce et revenons aux OESD , couleurs et autres Gutshot…

Un OESD est un tirage quinte bilatéral. Avant de fréquenter les sites de poker sur la toile (3) je disais « tirage par les deux bouts »…

Par exemple vous avez  JT  (Valet , dix) et le flop (arc-en-ciel) montre Q,2,9 (Dame, deux, neuf ). Les quatre 8 et les quatre  rois vous donnent  la quinte et probablement la meilleur main.

Les Reg vous diront que vous avez une côte de 5 contre 1 environ, c ‘est à dire que la probabilité de toucher un out est environ 16%. Vous aurez donc intérêt à suivre une mise si elle peut vous faire gagner plus de 5 fois son montant. (côte du pot supérieur à 5:1).

Prenons un cas limite en guise d’exemple :

Le pot fait 85€. Votre adversaire mise 15 euros, vous offrant une bonne  côte pour suivre de 100:15 soit 6,67:1.

Normalement sur 6 parties de ce type vous allez investir 6 fois 15 = 90 Euros

Vous allez perdre 5 fois mais gagner 1 fois 100€.

Sur 6 parties le gain théorique est de 10€ ( Soit 1,67€ par partie, qui est aussi la différence entre côte du pot de 6,67:1 et côte de 5:1)

Là aussi une simulation sur Python est très enrichissante :

import random

bankroll=1000
for i in range(1,10001):
    r=random.randint(1,6)
    bankroll=bankroll-15
    if (r==6):
        bankroll=bankroll+100
        print (i,(bankroll-1000)/i,bankroll)

Notre joueur dispose d’une bankroll de 1000€, et répète l’expérience suivante :

5 fois sur 6 il perd 15€ et une fois sur 6 il gagne 100€.

A chaque fois qu’il gagne on affiche successivement le rang de l’expérience, le gain par partie, et la bankroll du joueur.

Quelques extraits du log des résultats :

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>> 
33 -11.969696969696969 605
56 -11.428571428571429 360
57 -9.736842105263158 445
62 -8.548387096774194 470
73 -8.150684931506849 405
79 -7.405063291139241 415
89 -7.134831460674158 365
94 -6.48936170212766 390
99 -5.909090909090909 415
104 -5.384615384615385 440
113 -5.265486725663717 405
127 -5.551181102362205 295
129 -4.922480620155039 365
133 -4.473684210526316 405
137 -4.0510948905109485 445

Ainsi à la 137 ème main, notre bankroll a fondu de moitié, nous perdons environs 4€ par main…

Bad Run, tilt et dépression ? 

J’étais un peu dans cette situation quand je me suis décidé à rédiger cet article. Pourquoi,  ?

Simplement car je commençais à coucher mes tirages à bonne côte avec la certitude imbécile que… décidément ça ne rentrait plus !

Mon conseil après relaxation  et réflexion.

Continuer à jouer son A-game avec optimisme et un soupçon de fatalisme. Le véritable soucis est en amont, c’est la gestion de votre bankroll. Ce sera l’objet d’un futur billet.

Pour terminer un autre extrait du log des résultats :

9973 0.6322069587887296 7305
9981 0.6296964232040878 7285
9983 0.6365821897225283 7355
9995 0.6278139069534767 7275
9997 0.6346904071221366 7345

Après environ 1000 parties, le gain par expérience est encore bien loin du gain théorique mais, la bankroll a été multiplié par 7.

J’ai un peu modifié le programme pour afficher le résultats après 10 millions d’expérience :

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>> 
10000000 1.67556 16756600
>>>

Nous l’avons notre gain théorique !

Conclusion :

Soyons zen !

Initiation à Python : procédures et premières boucles

Wikipedia dixit :

Python est apprécié par les pédagogues qui y trouvent un langage où la syntaxe, clairement séparée des mécanismes de bas niveau, permet une initiation plus aisée aux concepts de base de la programmation.

Dans le cadre d’une structure « soutien-excellence » j’ai la chance d’animer pour des élèves de troisième, un module d’initiation à la programmation d’algorithmes numériques.

Oh ! nous y allons doucement, et si nous nous sommes surtout amusé la première fois avec l’IDLE,  l’environnement intégré à Python, nous avons aujourd’hui pénétré un peu dans la magie de la programmation.

def table(x):
    "la table de x"
    i=0
    while (i<10):
        i=i+1
        print i,"*",x,"=",x*i

def tables(x):
    "les x premières tables"
    i=0
    while (i<x):
        i=i+1
        table(i)
        print 30*"_"

Pas grand chose en effet dans ce petit bout de code :
Deux procédures définies par le mot clef « def ». Elles contiennent chacune une boucle « while » (tant que…)
(Ne me reprochez pas de ne pas utiliser « for », je m’adresse à des débutants)

Une procédure est une partie de programme indépendante des autres procédures.
La première procédure appelé « table » attend une valeur entière: La première ligne entre guillemets est une documentation de la procédure. Une fois le programme chargé et exécuté (Run Module F5), si l’on tape dans l’iIDLE « table(« …

im1

Python a la gentillesse de nous dire ce qu’il attend !

  • Que fait cette procédure ?

Elle crée une boite une variable i dans laquelle elle range qu’elle initialise avec la valeur 0. (i=0)

Et tant que la variable i est inférieure à 10 :

  1. Elle remplace le contenu de la boite la variable i par i+1.
  2. Elle affiche successivement i, le signe multiplié, le nombre de départ x, le signe « égal » est le produit de x par i.

On sortira donc du « tant que » quand i sera égal à 11 pour n’afficher que les tables de 1 à 10 :

im2

La deuxième procédure tables(x), elle affichera les tables de 1 à x :

im3

im4

Vous en savez assez pour étudier vous-même son fonctionnement !

  • Remarque

J’aurais aimé (mais ce ne fût pas le cas) devoir répondre à une question concernant la boite variable i présente dans les deux procédures, avec des valeurs différentes… et embrayer sur le caractère local des variables : les deux variables i sont différentes, chaque procédure à la sienne…