PYTHON .2 FEUILLE n° 3 d'exercices

                       . PYTHON .2      Feuille n° 3   janvier 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:

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

               elif     Condition:                            Si Condition:

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

              else:                                                Sinon:

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

            floor (  valeur )                      Donne la partie entière de la valeur

                                                              c-à-d "le plus grand entier relatif inférieur ou égal à la valeur"

                                                             En maths c'est    E(valeur)

                                                            Cela nécessite de faire appel au module  math

                                                         (  Donc avant il faut mettre      from math import*    )

                                                          Par exemple :   from math import*  

                                                                                       floor( 5.4) = 5

                                                                                       floor( − 3.4 )  = − 4

                                                          Remarque:  On peut aussi utiliser plus facilement

                                                                                 pour les réels positifs

                                                           int( valeur positive )

                                                                Pour les nombres réels positifs cela donne leur partie entière.

                                                                Mais attention cela ne marche pas pour les nombres réels négatifs.    

                                                               ( En fait cela donne la partie non décimale.)

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

                                                         décidé par l'ordinateur

                                                         ( Cela nécessiteavant  le menu     from random import*  )

         •   !=                                      Pour dire  ≠

                                                         Par exemple:      6!=5 

                                                          veut dire    6 ≠ 5          

          •      float(a)       transforme a en un décimal

                     Par exemple:      float(5)   donne 5.0

                                 Si a est déjà un nombre décimal cela ne fait rien

                     Par exemple:      float(5.)   donne 5.0

                      float(a)/b                   permet   d'avoir a / b comme 

                                                       nombre décimal .

                         Par exemple:     5 / 2   donne  2

                                                      5.0/ 2   donne 2.5

                                                      5/ 2.      donne 2.5

                                                  float(5)/2    donne 2.5

                                                  float(5/2) = float( 2) = 2.0

                             Si a et b ne sont pas déjà des nombres décimaux

                              a. / b comme   a /b.   donne aussi le résultat de la division

                                                                        de a par b sous forme décimale

                              Parfois il faut avant faire appel au module decimal

                                                     Par exemple  

                                                      float(11)/2 donne 5.5

                                                Cela revient à    11.0 /2

                                                L'ordinateur donne un décimal car 11.0 l'est

                                        Cela peut parfois avant nécessiter d'écrire:

                                                 from decimal import*

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

                                      Cela necessite avant      from decimal import*

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

                    DECOUVERTE  D'ALGORITHMES

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

  EXERCICE1:        Donner un script pour   

                          faire deviner un nombre   ( Jeu du pendu)

                  ( C'est comme pour le juste prix. L'ordinateur choisit au hasard un 

                    entier par exemple compris entre 1 et 100. Cet entier est 

                   mis dans une variable a. Puis l'ordinateur demande la saisie 

                  au clavier d'un entier mis dans une variable b. Il compare b avec a.

                  Il indique si b est trop grand ( b > a ) ou trop petit ( b < a )

                  ou est bon ( b = a ).

                  Tant que l'entier b saisi n'est pas a il propose 

                  une nouvelle saisie de b. ) 

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

   EXERCICE 2 :      Donner un script pour la     

                          simulation d'un lancer d'un dé
  

            AIDE:

   L'ordinateur doit donner un entier au hasard compris entre 1 et 6

   Une façon triviale consiste à faire appel à    randint(1,6).

   Mais vous pouvez essayer autre chose.

        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.

         On peut utilise     int(x )       plus facilement pour x positif

           comme sur certaines calculatrices.

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

  EXERCICE 3 :      Donner un script pour avoir la

                             factorielle d'un entier .    

                           On veut n!  avec n entier naturel

                          Rappel: 

                                0! = 1  par convention

                          Pour n dans IN*  on a:   n! =1×......×n

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

  EXERCICE 4 :        Donner un script qui donne la

                              valeur absolue d'un nombre

                            Rappel:

                                 La valeur absolue de x est:

                                            x     si x ≥ 0  

                                    et

                                         - x      si x ≤ 0

                                     Elle est notée | x |

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