RESUME: Python 2.7 utile pour E22

                        COURS:  Les Notions Indispensables  en Python 2.7       pour E22       2016                                       

    Ce qui est ici doit être parfaitement connu de mémoire comme le vocabulaire d'une langue.

            Si vous ne l'apprenez pas, aucun exercice n'est possible en python 2.7.

             •  Le variables          On les note par des lettres ou des noms   

                                                  une chaîne ,    un entier ,    un nombre décimal ,   un booléen,  une liste 

                                         par exemple :   a = " maison"      b=44        ciel= 5.6       d=1      e = [ 12 , 4 , 7. 5 ]

                                            En Python une liste se déclare en indiquant ce quelle représente.

                                             Par exemple     a = " maison"      indique que a est une chaîne

              •     print                 Pour demander l'affichage.         print  " texte"    avec un espace entre les deux  

                                               print   " Bonjour" , 44  , [ 2 , 4 , 5]    affiche successivement sur la même ligne 

                                                     la chaîne  puis 44  puis la liste

               •    raw_input(  )            Pour demander la saisie d'une chaîne 

                                                    nom=raw_input(" donner votre nom")   

                                                     Cela affichera donner votre nom. Vous devez ensuite répondre en mettant

                                                        une chaîne comme    "Albert"                                                      

                •    while Condition:            Par exemple      while i < 5:              veut dire   tant que  i < 5               

                                        Avant d'écrire    while i < 5:     il faut initialiser i , en donnant une valeur à l'entier i par exemple

                                               en posant  i = 0 sans quoi il ne se passera rien  car i n'est pas défini.

                                         Après    while i < 5:      il faut mettre en dessous ce que l'on demande

                                              de répéter.

                                          Enfin il faut poser i = i +1 ( incrémentation ) de façon à augmenter 

                                          de 1 le i à chaque répétition sans quoi on aura une boucle infinie car i

                                           sera bloqué à la valeur d'initialisation.

               • for i in range(... , ...):                 Cela nécessite le module   

                                                                  from random import*

                                                                  à mettre avant le programme. 

                                           Aucune initialisation de i n'est nécessaire, ni incrémentation, c'est automatique

                                                            Par exemple:    for i in range( 0,5):        ou encore     for i in range( 5):

                                       Cela veut dire : Pour  i prenant  les valeurs entières  successivement 0 , 1 , 2 , 3 , 4   pas  le 5                                                   

               • input( )                      Pour demander la saisie d'un nombre ou d'une liste.

                            Par exemple:              n=input()     demande la saisie d'un nombre ou d'une liste qui sera noté n.

                            Par exemple:            n=input("Donner un nombre")                écrit  Donner un nombre  

                                        puis attend en réponse un nombre  qui sera noté et enregistré comme étant n

              • A la différence d'autres langages  ce qui est sur une ligne n'est pas flottant .

                 Si la ligne précédente se termine par :  le retour ne se fait pas au même niveau. Il y a indentation.

                 En cas de doute mettez le curseur à droite de : puis appuyer sur la touche Entrée.

                   Le curseur se mettra là où il faut écrire.  

                     Un blanc de trop ou de moins en début de ligne peut bloquer l'exécution du programe             

             •   b=int(input("Entrez un entier : "))    

                                                       Cela affiche Entrez un entier puis attend la saisie de cet entier.

                                                        Si le nombre saisi n'est pas un entier b cela supprime sa partie décimale.

               •    if  Condition:              

                                           Si     Condition  :

                                                             On met en dessous ce qui doit se réaliser si la condition

                                                                       est vraie

                                             Dans le cas de plusieurs si, on met elif pour chaque        si supplémentaire                                

                                                               Une Condition comportant une égalité se met avec  = =                                                                           

                   •  else:                  

                                          Cela veut dire Sinon      On met en dessous ce qui doit se réaliser

                    •    **                    le double astérix signifie ^             par exemple:          13²          s'écrit     13**2

                                                On peut aussi mettre pow( 13, 2 )

                    •       *                           un seul astérix mis entre deux réels  est la croix × de la multiplication                               

                    •   n%p              donne le reste (entier) de la division de n par p            p non nul

                                      Par exemple:    5 %2   vaut 2                     

                    •Notation:                       Soit n un entier naturel etp est un entier naturel  non nul .

             •    from random import *         se met au dessus de   def  nomprogramme():    pour faire appel au  module random  

                •  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  avant de  mettre      from math import*    

                                                          Par exemple :     floor( 5.4) = 5     et          floor( − 3.4 )  = − 4

                                                        Pour les nombres réels positifs  on préfère utiliser     int( valeur positive )                                                                                                                       

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

                                                           Il faut avant mettre     from random import*                                                   

         •   ! =                                      Pour dire  ≠     c-à-d  différent

        •    <=                                          Pour  ≤                                                    

        •      float(a)              transforme la valeur numérique 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.

                                       Cela souvent nécessite avant       from decimal import*                                                                                          

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

                                      Cela nécessite avant      from decimal import*                                           

            •   Les connecteurs and , or , No sont utilisés   pour dire, et  ,ou , non                          

             •    Une liste comporte deux crochets fermés entre lesquels  ses termes sont séparés

                  par une virgule. C'est comme une "boîte où on rangerait des objets en les séparant par 

                  des petites cloisons."

                  Les termes sont des valeurs numérique ou des chaînes ou même de listes ou tableaux

                 Par exemple  L=[ ]       pour dire L est une liste vide

                                         C'est une façon de la déclarer.

                  Par exemple    F = [ 15 , " frois", 17.5 ]

                 Le premier terme  a pour indice 0 , le suivant 1 , etc

                Par exemple:                   LOU = [ " livre " , "table" , "crayon",  4.35 ]

                             Elle a 4 termes. Sa longueur est donc 4     On dit     len(LOU)=4

                             Le terme d'indice 0 est "livre".   Il est noté LOU[0]

                             Le terme d'indice 3 est le réel   4.35    c'est LOU[ 3]

                             type(LOU[0])    donne le type du terme " livre " d'indice 0  . C'est str 

                •  Ainsi chaque élément d'une liste de n éléments ( n dans IN* )

                         est repéré par un entier de 0 à n − 1 qui est son indice  .         

                   •   append          

                                 Nom de la liste . append(  ce que l'on veut ajouter à la fin de la liste )

                              par exemple: Soit   L =[ 44 , 25 , 17 ]        L.append( 53)   fait que L= [ 44 , 25 , 17, 53 ] 

                                  Cela   permet d'ajouter qu'un seul terme à la fois.

                    • insert                

                               Nom de la liste . insert(indice i , ce que l'on veut rajouter à la place d'indice i )

               •  Tableau:      C'est une liste de listes

                               Par exemple:    A = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ]

                     for line in A:

                           print line

                         Affiche  A  avec chaque terme de A  sur une ligne différente

                                               [ 1 , 2 , 3 ]

                                                [ 4 , 5 , 6 ]

                    Quand les listes du tableau ont le même nombre de termes on a une matrice

        •    [[0 for x in range(3)]for x in range(2)]   crée  le tableau         [[0,0,0],[0,0,0]]

                       qui une matrice de deux lignes et trois colonnes

       •  Soit a et b deux entiers naturels avec a ≤ b .

           for i in reversed(xrange(entier b)):    

            donne le compte à rebours à partir de l'entier b − 1 jusqu'à 0

              Par exemple :    for i in reversed(xrange( 3)):

                     i  sera dans l'ordre successivement   2 puis 1 puis 0

        • for i in reversed(xrange(entier a,entier b))     donne le compte à rebours à partir de l'entier b −1 jusqu'à a

              Par exemple :      for i in reversed(xrange(2,6 )):

                                      i  sera dans l'ordre successivement    5  puis 4 puis 3 puis 2

        • len( liste)                donne le nombre de termes de la liste 

       • liste.sort()              Ordonne  dans l'ordre croissant la liste  de valeurs

                                       Par exemple:  L= [18,5,9,6]

                                                                 F =L.sort()

                                                              print  F                 donne [ 5,6,9,18] 

        • Opération dans une liste:

                 Exemple:    L = [ 2 , 8 ,3 , 5  ]

                                     F= [ element*2 for element in L ]

                                    Cela donnera  F = [ 4 , 16 , 6 , 10]      

                                     G=[ element**2 for element in L ]

                                    Cela donnera  F = [ 4 , 64 , 9 , 25 ]   

                                      H =  [ element + 3 for element in L ]

                                  Cela donnera  H = [ 5 , 11 , 6 , 8 ] 

                    On peut mettre une lettre comme i  pour remplacer  element

              Exemple :     L = [ 2 , 8 ,3 , 5  ]

                              En posant   L[ 1 ] = 44

                               L devient     L = [ 2 , 44 ,3 , 5  ]

          • Concaténation de deux listes ou de deux  chaines avec +:

              On ne peut pas concaténer une liste avec une chaîne. Ce n'est pas de même type

              Par exemple:

                           L= [1,2,3]
                            F= [4,5,6]
                        Si l'on écrit     G = L+ F
                        alors     G   = [ 1,2,3,4,5,6]

                  Par exemple:          a="bonnes"

                                                     b="vacances"

                                               Si l'on écrit c = a + b

                                             alors  c ="bonnesvacances"  

                + a l'avantage de pouvoir ajouter en une seule fois plusieurs termes

                               à une liste en les mettant sous forme de listes.

            •Recherche d'un élément d'une matrice.

                    Exemple :     A = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ]                          

                         Le 3   est dans A[0] et il y est d'indice 2

                   Donc     3 = A[0][2]

        •   round                    round( nombre décimal, un entier n )

                                            arrondi le nombre décimal avec n décimales

                               Par exemple :

                                             round( 7.789456, 2 ) donne 7.79

                                      Cela se fait alors  au centième supérieur  

      • pow( x , n)      où x est un réel et n un entier  ( x et n ne peuvent être nus tous les deux )

                                    cela donne  xⁿ  

                           Par exemple:    pow( 3 , 2 )    donne  9     

      •  Utilisation de:      phrase.split()  

                   Cela  transforme la chaîne phrase en une liste de chaines qui sont

                  les mots de la phrase, séparés par des virgules.

                     Par exemple :     L=" Il fait beau ce matin"

                                                   L.split()

                           Alors   on obtient    [ 'il', 'fait' , 'beau','ce','matin']

                          Les espaces deviennent de virgules et on a une liste              

                 • Utilisation de L[:i]   et   L[i:]  pour une liste ou une chaîne L 

                                      avec    0≤ i < len(L]

                    L[:i]  est la liste des termes ou caractères d'indices strictement inférieur à i 

                    L[i:]   est la liste des termes d'indices supérieurs ou égaux à i 

                    Par exemple:           L="bonjour"

                                                      L[1:]    est     onjour       ( on commence à l'indice 1 )    

                                                      L[:3]      bon                      ( on s'arrête à l'indice 3 )  

           •   randint(1,10)                 crée un entier aléatoire entre 1 et 10  

           •      join                          join(liste de chaîne)              avec from string import*  

                       Par exemple:   L =[ "Bon","jour"]

                                                  print join(L)

                                             donne     Bon jour

                         La virgule donne un espace. On a une chaîne.

                        (  C'est le contraire de split)

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