PYTHON .2 INFO. FEUILLE n°3

        PYTHON 2.5  ou 2.7    INFO   FEUILLE  n° 3     ALGORITHME       BTS1     2012  

------------------------------------------------------------------------------------------------------

  COURS:   

                     Thème:    

          •    from random import *         se met au dessus de   def  nomprogramme():

                                                           pour faire appel au  module random  

                                                                s'il est installé 

          •   while  Condition:                            Tant que Condition :

                  ......                                                .......

          •   if  Condition:                                   Si Condition:

                   .....                                                   ....

              else:                                                Sinon:

                    ......                                                     ........ 

            floor (  valeur )                    Donne la partie entière de la valeur ( positive ou négative ).

                                                           On peut aussi utiliser plus facilement

                                                           int( valeur positive )

                                                Attention cela nécessite avant  le module  complémentaire.   

                                                          from math import*    

             randint(0,100 )               Cela donne un entier entre 0 et 100 au hasard

                                                         décidé par l'ordinateur.

         •   !=                                      Pour dire  ≠

                                                         Par exemple      6!=5 

                                                          veut dire    6 ≠ 5          

          •      float(a)/b          permet  avec le module decimal d'avoir  a / b comme 

                                          nombre décimal .

                                                     Par exemple  

                                                      float(11)/2 donne 5.5

                                        cela nécessite avant le début du programme écrire:

                                                 from decimal import*

           •  random()                               donne un réel au hasard de l'intervalle [ 0;1[          

----------------------------------------------------------------------------------------

  EXERCICE 1 :  

                                    Donner un script pour

                                  faire deviner un nombre   ( Jeu du pendu )

          (  Comme au juste prix. Mais ici l'ordinateur choisit au hasard un entier.

             Puis il demande la saisie d'un entier. Suivant celui-ci, il indique si

                            l'entier entré est trop grand ou trop petit ou est le bon)

              Modifier le programme pour mettre un compteur.

---------------------------------------------------------------------------------------

Réponse:

from random import *

def dev(): 
                       #  a est l'entier compris entre 0 et 100 choisi au hasard par le programme
      a=randint(0,100)
                        #  b est la variable qui stocke les tentatives de l'utilisateur
      b=int(input("Entrez un entier : "))
      while b!=a:
           if b>a:
               print"votre nombre est trop grand."
          else:
               print"votre nombre est trop petit."
          b=int(input("Entrez un autre entier : "))
      print "votre nombre est le bon."

                           On  obtient par exemple:

>>> dev()
Entrez un entier : 15                                    Après chaque réponse Entrée
votre nombre est trop petit.
Entrez un autre entier : 59
votre nombre est trop petit.
Entrez un autre entier : 150
votre nombre est trop grand.
Entrez un autre entier : 100
votre nombre est trop grand.
Entrez un autre entier : 90
votre nombre est trop grand.
Entrez un autre entier : 80
votre nombre est trop grand.
Entrez un autre entier : 70
votre nombre est trop grand.
Entrez un autre entier : 65
votre nombre est trop grand.
Entrez un autre entier : 60
votre nombre est le bon.
>>>

            On peut proposer une amélioration qui donne le nombre

            de coups nécessaires en rajoutant un compteur.

from random import*
def pendu():
       a=randint(0,100)
       b=int(input("Donner un nombre entier naturel  "))
       i=1
       while b!=a:
             if b>a:
                  print "trop grand  "
            else:
                   print " trop petit  "
            b=int(input("Donner un nombre entier naturel  "))
             i=i+1
       print " C'est gagné "
       print " en ",i, " coups "

       Par exemple
>>> pendu()
Donner un nombre entier naturel  60
 trop petit
Donner un nombre entier naturel  10
 trop petit
Donner un nombre entier naturel  80
 trop petit
Donner un nombre entier naturel  90
 trop petit
Donner un nombre entier naturel  96
trop grand
Donner un nombre entier naturel  95
 C'est gagné
 en  6  coups 

>>>

-----------------------------------------------------------

   EXERCICE 2 :

                     Donner un script pour la

                  Simulation d'un lancer d'un dé
     ( Le programme doit générer un entier compris entre 1 et 6.

         Un cas trivial est d'utiliser randint(1,6)

          Mais cela revient à utiliser le programme qui est dans le module random  )

---------------------------------------------------------------------

   REPONSE:   

    Remarque :
      •   L'instruction floor(x) renvoie la partie entière du réel x,

          c'est-à-dire le plus grand entier (relatif) inférieur ou égal à x.

           C'est E(x) en math.

         random renvoie un réel  quelconque de l'intervalle [ 0 ,1[ 

              On peut considérer comme programme:

from random import*

from math import*

def jeter():
      jet=floor(6*random()+1)
      print "le résultat du jet du dé est " , jet

                 On obtient par exemple:

>>> jeter()

5    

     EXPLICATION::

              random()   donne un réel au hasard de l'intervalle [ 0;1[

              6*random() donne donc un réel au hasard de l'intervalle [ 0 ; 6 [

               Ainsi  6*random() + 1 donne un réel de l'intervalle [1; 7 [

              La partie entière d'un réel de l'intervalle [ 1 ; 7 [ est un des entiers naturels :

              1 ; 2 ; 3 ; 4 ; 5 ; 6

                floor(6*random()+1) donne  au hasard la partie entière d'un réel

              de l'intervalle [ 0 ; 7 [

             Cela donne au hasard l'un des entiers :   1 ; 2 ; 3 ; 4 ; 5 ; 6

-----------------------------------------------------------------------------------------------
  EXERCICE 3 :        
                       Donner un script qui donne  n !  ,   factorielle d'un entier

                       n étant un entier naturel non nul .

-------------------------------------------------------------------

    REPONSE:

                On peut considérer:

from random import*

def fac():

       n=int(input("Entrez un entier naturel non nul : "))
       a=1
       for i in range(1,n+1):

       #   l'entier i prend donc successivement les valeurs 1,2,3,...,n
             a=i*a
       print "La factorielle de ",n, "est ",a       

                            On obtient:

>>> fac()
Entrez un entier naturel non nul : 7
La factorielle de 7 est 5040
>>>

                      Remarque:  En déplaçant print à la verticale du i de for i in ...

                      on a toutes les étapes de la formation de n!

             Pour ne pas se limiter à n un entier non nul on peut proposer:

from random import*

def  fac():

        n=int(input("Entrez un entier naturel : "))

        if n==0:

              print "La factorielle de ",n, "est ",1

       else:
               a=1
               for i in range(1,n+1):

 #   l'entier i prend donc successivement les valeurs 1,2,3,...,n
                     a=i*a
               print "La factorielle de ",n, "est ",a    

                      On obtient par exemple:

>>> fac()
Entrez un entier naturel : 0
La factorielle de 0 est 1
>>>

----------------------------------------------------------------------------------------------  

     EXERCICE 4 :              valeur absolue

         Donner un script qui donne la valeur absolue d'un réel .

----------------------------------------------------------------     

       REPONSE:

                       On peut considérer:

def val():

       x=input("Entrez un nombre réel: ")

       if x>=0:
            print "la valeur absolue de", x, "est "," |" , x , "| =" , x
       
       else:
       
               print "la valeur absolue de", x, "est "," |" , x , "| =" , -x

 

                       On obtient par exemple:

>>> val()
Entrez un nombre réel: -1.25
la valeur absolue de -1.25 est | -1.25 | = 1.25
>>>

                       Autre situation:

>>> val()
Entrez un nombre réel: 3.45
la valeur absolue de 3.45 est | 3.45 | = 3.45
>>>

---------------------------------------------------------------