PYTHON.2 INFO FEUILLE n° 7 PYTHON 2 BTS SIO
-------------------------------------------------------------------------------------------------------------
COURS:
Thème :
• A=[]
( Cela veut dire que A est une liste vide)
• for x in range():
( Cela répète ce qui est en dessous autant de fois que l'entier entre parenthèse.
La lettre x peut être emplacée par tout autre lettre )
• A[i -1][j-1]
( C'est le terme de rang ( i ; j) de la matrice A )
• nom de liste.append( )
( le contenu entre parenthèse est rajouté au bout de la liste comme terme )
• for line in A:
print line
( Cela affiche la matrice A verticalement.)
• [[0 for x in range(3)]for x in range(2)]
( Cela donne une matrice à 2 lignes et 3 colonnes avec uniquement des 0)
[0 for x in range(3)] donne [0,0,0] puis [ [0,0,0]for x in range(2) ] donne
[[0,0,0],[0,0,0]]
------------------------------------------------------------------------------------------------------
EXERCICE 0
1. Que donne le script suivant?
def ger():
li1=[ 'julien','andre','marc']
li2=['omega','triangle','losange']
mt=[]
mt.append([li1,li2])
print mt
2. Ecrire un script qui demande deux listes L1 et L2 à l'aide de input( " ... " )
puis qui donne la liste [L1 , L2 ] .
----------------------------------------------
REPONSE:
1. On obtient la matrice de type ( 2 ; 3 ) , c'est-à-dire la liste:
[ ['julien','andre','marc'],['omega','triangle','losange'] ]
2. Le script suivant répond;
def fer():
L1=input("Donner une liste de trois termes ")
L2=input("Donner une liste de trois termes ")
mt=[]
mt.append(L1)
mt.append(L2)
print mt
On obtient une liste dont les deux termes sont L1 et L2.
C'est une matrice de type ( 2 ; 3 )
Par exemple:
>>> fer()
Donner une liste de trois termes [1,2,3]
Donner une liste de trois termes [4,5,6]
[[1, 2, 3], [4, 5, 6]]
>>>
Attention si l'on remplace :
mt.append(L1)
mt.append(L2)
par mt.append([L1,L2] )
on obtient une liste dont la liste de listes [L1,L2]
est l'élément
Par exemple:
>>> fer()
Donner une liste de trois termes [1,2,3]
Donner une liste de trois termes [4,5,6]
[[[1, 2, 3], [4, 5, 6]]]
>>>
Attention: mt.append(L1,L2) ne donne rien
car .append( ... ) est à un argument (c-à-d à une place )
-----------------------------------------------------------------------------
EXERCICE 1 bis
Soit la matrice A de type ( 3 ;3) donnée:
| / | 1 | 2 | 3 | \ | |
| A = | | | 2 | 4 | 6 | | |
| \ | 7 | 8 | 0 | / |
déjà introduite sous la forme
A=[ [ 1,2,3],[2,4,6],[7,8,0] ]
1. Comment obtenir le terme de A de rang ( 2;3)
qui est 6?
2. Comment remplacer le terme de A de rang ( 2;3 )
par 44 ?
----------------------------------------------------------
Réponse:
1. Ecrire le terme 6 de A de rang ( 2 ; 3 ).
Voici un script possible.
def exemple():
A=[[1,2,3],[2,4, 6 ],[7,8,0]]
print A[1][2]
On obtient:
>>> exemple()
6
>>>
Explication:
6 est dans le second terme [2,4,6] de A.
Or le second terme de A est d'indice 1.
6 est le troisième terme de la liste [2,4,6].
Or le troisième terme de la liste [2,4,6] est d'indice 2
A[1][2] est donc le terme de rang ( 2 ; 3 ) de A.
c-à-d A[2 -1][3-1] est 6
Cela donne:
>>> exemple()
6
>>>
2. Remplacement dans A de 6 par 44
Voici un script possible
def exemple():
A=[[1,2,3],[2,4, 6 ],[7,8,0]]
A[1][2]=44
print A
On obtient:
>>> exemple()
[[1, 2, 3], [2, 4, 44], [7, 8, 0]]
>>>
On a bien remplacer 6 par 44.
-----------------------------------------------------------
EXERCICE 1 ter
Soit la matrice A de type ( 3 ;3) donnée:
| / | 1 | 2 | 3 | \ | |
| A = | | | 2 | 4 | 6 | | |
| \ | 7 | 8 | 0 | / |
déjà introduite sous la forme
A=[ [ 1,2,3],[2,4,6],[7,8,0] ]
Comment demander un affichage vertical
des lignes de A ?
------------------------------------------------------------
Réponse:
Voici un script qui répond:
def exemple():
A=[[1,2,3],[2,4,6],[7,8,0]]
for line in A:
print line
On obtient :
>>> exemple()
[1, 2, 3]
[2, 4, 6]
[7, 8, 0]
>>>
Cela a d'avantage l'apparence de A.
--------------------------------------------------------------
EXERCICE quatro
Que donne le script suivant?
def exemple():
B=[[0 for x in range(3)]for x in range(2)]
print B
2.Que donne le script suivant?
def exemple():
B=[[0 for x in range(3)]for x in range(2)]
for line in B:
print line
( la lettre x peut être remplacée par une autre lettre .On peut prendre y
pour le second x si l'on veut.)
3. Que donne le script suivant?
def exemple():
B=[[0 for x in range(3)]for x in range(3)]
for i in range(3):
B[i][i]=1
for line in B:
print line
--------------------------------------------------
REPONSE:
1. On obtient la matrice nulle de type ( 2;3) :
>>> exemple()
[[0, 0, 0], [0, 0, 0]]
>>>
2. On obtient la matrice nulle de type ( 2;3)
disposée verticalement.
>>> exemple()
[0, 0, 0]
[0, 0, 0]
>>>
3. On obtient ma matrice unité d'ordre 3 disposée verticalement.
>>> exemple()
[1, 0, 0]
[0, 1, 0]
[0, 0, 1]
>>>
-----------------------------------------------------------------------
EXERCICE 1
Obtenir un tableau à deux dimensions formé à partir de deux listes de deux termes 0.
------------------------------------------------------------------------------------------------------
Réponse :
def tb():
tableau=[] # La liste appelée tableau est vide
for x in range(2): # Affîche deux fois la ligne qui suit
tableau.append([])
for y in range(2):
tableau[x].append(0)
print tableau
Résultat du script
>>> tb()
[[0, 0], [0, 0]]
>>>
En fait progressivement le résultat se construit ( pour le voir il suffit de
mettre print aligné avec tableau[x].append(0).
----------------------------------------------------------------------------------------------------------
EXERCICE 2
Soit le script suivant:
def tab():
tableau=[]
for x in range(3):
tableau.append([])
for y in range(4):
tableau[x].append(1)
print tableau
Que donne-t-il ?
-------------------------------------------------------------------------------
REPONSE:
Le scrip donne le tableau suivant à 3 lignes et 4 colonnes.
>>> tab()
[ [ 1,1,1,1] , [ 1,1,1,1] , [ 1,1,1,1] ]
>>>
En fait cela se présente comme une liste de 3 listes de quatre termes
tous égaux à 1.
-----------------------------------------------------------------------------------------------------
EXERCICE 3
Que produit le script suivant?
def jan():
for i in range( 5 ):
print 'a'
------------------------------------------------------------------
REPONSE:
Cela affîche 5 fois le a à la ligne sur cinq lignes
>>> jan()
a
a
a
a
a
>>>
-----------------------------------------------------------------------------
EXERCICE 4
Soit le script suivant:
def tab():
tableau=[]
for x in range(3):
tableau.append([])
for y in range(4):
tableau[x].append(' bien' )
print tableau
Que donne-t-il ?
-----------------------------------------------------------------------------------
REPONSE:
Le script donne la matrice 3 ligne et 4 colonnes :
>>> tab()
[ [ bien,bien,bien, bien] , [ bien,bien,bien, bien] , [ bien,bien,bien, bien] ]
>>>
-----------------------------------------------------------------------------------------------
EXERCICE 5
Créer un script qui donne la matrice
| /1 | 5 | 6 \ |
| |0 | 7 | 5 | |
| \ 5 | 4 | 2 / |
--------------------------------------------------------------------------------------------
Réponse:
On peut considérer :
def tb():
L1 = [1 , 5 , 6 ]
L2 = [0 ,7 , 5 ]
L3 = [ 5 , 4 ,2]
mat= [L1,L2,L3]
print mat
On obtient quand le script tourne:
>>> tab()
[[1, 5, 6], [0, 7, 5], [5, 4, 2]]
>>>
--------------------------------------------------------------------------------------------
EXERCICE 6
Ecrire un script qui échange à la demande deux termes désignés d'une liste,
par exemple dans une liste de quatre termes.
------------------------------------------------------------------------
Réponse:
On peut considérer:
def perm():
lis=[' p','u','e','r']
print lis
print (" lis est une liste de 4 termes")
i=input(" Donner l'indice du premier terme à permuter")
j =input(" Donner l'indice du second terme à permuter")
t=lis[i]
lis[i]=lis[j]
lis[j]=t
print lis
On obtient quand on fait tourner le scrip:
>>> perm()
[' p', 'u', 'e', 'r']
lis est une liste de 4 termes
Donner l'indice du premier terme à permuter 2
Donner l'indice du second terme à permuter 3
[' p', 'u', 'r', 'e']
>>>
On a obtenu la permutation de e et r.
Remarque :
On peut remplacer
def perm(): par def perm(a,b):
pour indiquer qu'il y a deux variables
mais alors pour faire tourner le programme
il faudra mettre par exemple
>>>perm(1,2) pour que le programme se lance
------------------------------------------------------------------------------------------