PYTHON.2 FEUILLE n ° 14 D'EX

                   PYTHON 2   FEUILLE     n°14     D'EXERCICES    MAI 2012

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

  COURS:                    

                Thème:

                          •  Pour dire:

                                      Si a = 3 alors b = 5

                            on écrit :

                                      if a==3:

                                          b=5

                              Le symbole = dans une condition est remplacé par ==           

                          • Soit N un entier naturel.

                                  N%2 désigne le reste entier de la division de N par 2.

                                 Exemple:     N = 13       On a :   13 = 2 × 6 +   avec  0 ≤ 1 < 2

                                                    On a:         N%2 =

                                 Exemple:     N = 14           On  a :     14 =  2 × 7 +   avec  0 ≤ 0 < 2

                                                    On a :         N%2 =

                                                                                            diven.png

                              • Soit N un entier naturel.

                                     int( N / 2 )  est  le quotient entier de la division de N par 2                                      

                                  Exemple:     N = 13       On a :   13 = 2 × 6  + 1   avec  0 ≤ 1 < 2

                                                    On a:           int( N / 2 ) = 6 

                      • Médiane d'une liste T croissante de N valeurs:

                             •• Si N est pair   c-à-d   si le reste de la division de N par 2 est 0

                                alors  on considère la moyenne arithmétique  des N / 2 ième et

                                ( N / 2 ) + 1 ièmes termes des la liste. 

                              •• Si  N est impair c-à-d  si le reste  de la division de N par 2 est non nul

                                  alors on considère la ( N + 1) / 2  ième terme de la liste.

                           •   Attention:   Le k ième terme d'une liste  est celui d'indice k - 1. 

                           • Soit T une liste.

                                          len(T)    est le nombre de ses termes.

                                   Les indices  des termes de T  sont les entiers i  tels que

                                           0 ≤ i ≤ len(T) 

                           •  float( valeur)

                                            donne la valeur sous forme décimale.

                           •  Programme multitâches. Un programme principal 

                                fait apppel à plusieurs scripts qui renvoie des résultats 

                                 à l'aide de

                                               return

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

     EXERCICE 1

Que donne le programme suivant?

import decimal
def md(T,N) :

      if N%2 ==0 :

                                           # Cela veut dire: Si N est pair

           i = int(N/2)-1
                                          # Le -1 est du au fait que la première valeur est d'indice 0 
           return float(T[i] + T[i + 1])/2
      else :
            i = int(( N+1)/2)-1
                                           # Ne pas oublier que la première valeur est d'indice 0 
            return T[i]

# PROGRAMME PRINCIPAL#
###################
T=input("Entrer une liste croissante de valeurs ( entre crochets ): T = ")
N=len(T)
print "Votre liste contient",N,"valeurs"
print "La médiane est",md( T,N)

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

    EXERCICE 2

   Que fait le programme suivant, sachant que

   T  est une liste ou un tableau de N valeurs (   N =len(T)    ),

    h et k  sont deux entiers naturels tels que 0 ≤ h < k < N ?

def indmi(T,h,k):

      m=T[h]

                          # m est le terme d'indice h de la liste T

      ind=h
      for i in range(h+1 , k ,1):

                       #  Les entiers i sont  entier entre  h+1 accepté  et k exclus.

                       # Les entiers i sont dans une progression arithmétique de raison 1 de premier terme h + 1 et de dernier terme ici k - 1
           if T[i]<m

                                # Si le terme d'indice i de T est plus petit que le terme d'indice h de T
                m= T[i]
                ind = i
      return ind

                               # Attention le return est au niveau du for

#PROGRAMME PRINCIPAL#

    ####################

T=input("Entrer une liste d'au moins trois valeurs ( entre crochets ): T = ")
N=len(T)

print " Votre liste comporte", N," valeurs"

k=input(" Donner un  indice k entre 2 et N − 1 :  k = " ) 

h=input(" Donner un  indice h compris entre  0 et k non compris : h = ")
print  "Quand  l'indice est entre h et k ( k exclu) la valeur mini est d'indice : "indmi(T,h,k)

                                   ATTENTION :  2 ≤  k < N    Par exemple si N = 4   k ne peut être que 2 ou 3

                                                  ind n'est pas l'indice du plus petit élément de la liste T

                          ind est l'indice du plus petit terme de T uniquement pour ceux d'indices compris entre h compris et k - 1 compris.

   Par exemple:

>>>

Entrer une liste d'au moins trois valeurs ( entre crochets ): T = [3,17,5,23]
 Votre liste comporte 4  valeurs
 Donner un  indice k entre 2 et N − 1 :  k = 3
 Donner un  indice h compris entre  0 et k non compris : h =
0
Quand  l'indice est entre h et k ( k exclu) la valeur mini est d'indice :  0
>>> 

    Par exemple:

>>> 
Entrer une liste d'au moins trois valeurs ( entre crochets ): T =
[17,2,5,3]
 Votre liste comporte 4  valeurs
 Donner un  indice k entre 2 et
N − 1 :  k = 3
 Donner un  indice h compris entre  0 et k non compris : h = 1
Quand  l'indice est entre h et k ( k exclu) la valeur mini est d'indice :  1

>>> 

   Par exemple:

>>> 
Entrer une liste d'au moins trois valeurs ( entre crochets ): T = [1,8,3,24]
 Votre liste comporte 4  valeurs
 Donner un  indice k entre 2 et N-1 :  k =
3
 Donner un  indice h compris entre  0 et k non compris : h = 1
Quand  l'indice est entre h et k ( k exclu) la valeur mini est d'indice :  2
>>> 

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

   EXERCICE 3   

  Que donne le script suivant?

def ech(T,a,b):

                    # T est une liste. temp est une variable auxliaire. 

                   # a et b sont deux indices de termes de la liste T

                   # Ce script permet de permuter les termes d'indices a et b

      temp = T[a]
      T[a] = T[b]
      T[b]= temp

                 # T[a],T[b]=[b],T[a] peut remplacer ces trois lignes

    return T

#Programme principal#

  #################

T=input("Entrer une liste de N valeurs avec N ≥ 3 ( entre crochets ): T = ")
N=len(T)

a =input(" Donner un  indice a   ( compris entre 0 et N-1) :  a = " )

b=input(" Donner un  indice b  ( compris entre 0 et N-1 ):  b = " )

print "La liste est devenue: T= ",ech(T,a,b)

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

  EXERCICE 4

       Exercice de synthèse.

      Que fait le programme suivant?

import decimal

def Tri_Bulle(T,N):                                                          

       for i in xrange(N):   

                                                              # i varie entre 0 et N-1     

             for j in reversed(xrange(i,N)):     

                                                              # j varie entre N-1 et i en décroissant         

                   if T[j]<T[j-1]:         

                        t=T[j]         

                       T[j]=T[j-1]           

                       T[j-1]=t     

       return T

                                 # Attention le return est au niveau du premier for

def md(T,N) :      

       if N%2 ==0 :

                                                # Cela veut dire: Si N est pair

            i = int(N/2)-1
                                                     # Le -1 est du au fait que la première valeur est d'indice 0 
            return float(T[i] + T[i + 1])/2
      else :
            i = int(( N+1)/2)-1
                                                     # Ne pas oublier que la première valeur est d'indice 0 
            return T[i]
# PROGRAMME PRINCIPAL#
    ###################
T=input("Entrer une liste d'au moins trois valeurs ( entre crochets ): T = ")
N=len(T)
print "Votre liste contient",N,"valeurs"

print "La liste ordonnée est : T = "Tri_Bulle(T,N)

print " Sa médiane est : MED = ",md(T,N)

###########################################

                                   ATTENTION si vous copiez ce texte , à chaque ligne il faudra vérifier l'indentation

                              l'interface graphique n'étant pas la même

               Par exemple:

>>> 
Entrer une liste d'au moins trois valeurs ( entre crochets ): T =
[12,5,7,15,18]
Votre liste contient 5 valeurs
La liste ordonnée est : T =  [5, 7, 12, 15, 18]
 Sa médiane est : MED =  12
>>> 

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