PYTHON 2.7 RENTREE BTS1 ALGORITHMIQUE

                            BTS 1  PYTHON 2   RENTREE   Septembre 2016

      Thème: Variables, saisies, affectations, affichages

                       Incrémentation, implémentation, indentation

                          % ,   //,  **  , rôle du point , pow(   ,   )  , abs(    )  , sqrt(   )  , floor(      ) 

                      Modules:  random   , math , decimal

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

         1.  Il y a différents types de variables:

               integer  ( entiers  )                               comme   5       < type'int' >

              float   (nombre à virgule )                         comme  12.13           type'float'

             string ( chaînes de caractères entre aiguillemets)   comme   " Bonjour"         < type "str" >

             liste   ( entre deux  crochets fermés )         comme        [ 12 , 44.5 , "bonjour" ]

            booléen                Une variable booléenne prend  0 ou 1 comme valeurs        < type'bool' >

    2. Il n'y a pas de déclaration de variable en Python 2.

                   Par exemple on écrit   a = 44   pour dire que a est une variable numériques.

                   44 n'est qu'une valeur temporaire ici pour créer a

    3.Saisie: Pour demander une saisie par l'utilisateur on utilise 

                    a = input()       On attribue à la variable a  la " valeur numérique" saisie à l'écran

     ou         a = input(" Saisissez ")     qui permet en plus d'afficher Saisissez avant la saisie

     ou     a = raw_input()         On attribue à la variable a  la chaîne saisie à l'écran

    ou      a = raw_input(" Donner votre nom")   qui permet en plus d'afficher Donner votre nom avant la saisie

   4. Affectation: Tableau pour voir le contenu des variables  après les affectations:

Affectations   A        B     
A ← 1   1    ni  
B ← A + 2   1    3  
A ← B −  1   2    3  
B ← A − 1   2    1  
A ← B + 4   5    1  
B ← A + 4   5    9  

                          (  ni    signifie non initialisé  )

    5. Conventions:

            •    Incrémenter une variable c'est lui ajouter 1    comme   a =  a + 1     (  a devient a + 1 )

                                       Cela correspond à l'affectation a ←  a + 1

            •   Implémenter c'est écrire un programme.

           •    Indenter c'est décaler vers la droite la ligne suivante.

     6. Commandes.

                        Restequotient

         5 / 2   donne   2    et non 2.5

         Par contre  5/ 2.      donne 2.5

         round( 3.256, 2)  donne 3.25   on a seulement 2 décimales

       round(4 /3. , 2) donne 1.33   avec deux décimales

     ( Attention  on doit avoir déjà un décimal pour que cela serve )

       divmod( 17 , 3 ) = ( 5 , 2 )   cela donne le quotient 5  puis le reste entier 2

             2**8     = 28   =  256              ** remplace ^

          pow( 2 , 8 ) = 256   aussi

          abs( − 5 ) = 5   cela correspond  la valeur absolue de − 5

   7. Avec le module math  on dispose d'autres commandes 

              On met avant       from math import*

             sqrt( 2 ) donne la racine carrée de 2  avec beaucoup de décimales

                              2**0.5  la donnerait aussi

           floor( − 1.5 ) = − 2   c'est la partie entière de - 1,5   ( En maths c'est E( − 1,5)   )

          floor( 1.5) = 1

           Dans le cas où le nombre décimal a est positif   int( a ) convient aussi.

          Par contre   int ( − 1.5 ) =  − 1   Ce n'est pas la patie entière de  − 1.5

     8. Avec le menu  random

                    On met avant     from random import*

                  random() donne un réel de [ 0 , 1 [

                  randint(1 , 100) donne un entier aléatoire de l'intervalle [ 1 , 100 ]

     9. Types des variables:

              type( ( 5<2) )  donne  < type' bool'    

              type( " soleil")  donne  < type "str" >

             type( 44)   donne   < type'int' >

             type(14.7)    donne < type'float' >

     10. Booléens

              ( 5 < 2 )  renvoye False

              ( 7 > 6 )    renvoye True

     11. Déclarations simultanées.

               X , Y , Z  = 12 ,  4.1  , 7

            signifie          X = 12      Y = 4.1      Z = 7

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

      Effet d'un algorithme:

        1. Que fait? :

             def exemple():

                    X , Y , Z  = 12 , 4.1,7

                    print X , Y , Z

                    Z= X

                    X= Y

                    Y= Z

                    print  X , Y

               Réponse:  En faisant exemple() dans la fenêtre d'exécution Python shell

                                 il permute les valeurs de X et Y.

                                 Z est une variable auxiliaire

                      12        4.1    7

                       4.1     12

       2. Que fait?

              def trans():

                    N=input("Donner un entier N :  N =  " ) 

                    a= N−4

                    a=a*N

                    a=a+4

                    print a

                   Réponse:

                  Il donne ( N − 2 )2  

               Explication:

                                             a est N−4

                                  puis   a est N− 4*N

                                  puis   a est    N − 4*N + 4

                                      c-à-d     a est   N − 2 * 2*N + 22

                                     c-à-d  a est     ( N − 2 )2     

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