Chapitre 1 Introduction `a Python et Xcas/Giac - IMJ-PRG

Chapitre 1
Introduction à Python et Xcas/Giac
1.1
Présentation, Installation et documentation
Sur le site du jury du capes http://capes-math.org/index.php?id=epreuves-orales, on
trouve un paquet python2.7 qui contient en particulier l’éditeur idle capable de trouver la documentation officielle 1 de python sans connexion internet. C’est pourtant souvent plus simple de
débuter avec un livre. Par exemple le début du livre de Xavier Dupré. (Une version modifiée est
disponible sur sa page http://www.xavierdupre.fr/mywiki/InitiationPython)
Xcas est l’interface graphique du logiciel et de la librairie giac (cf http://www-fourier.
ujf-grenoble.fr/~parisse/giac.html). Sa documentation interne est tres importante, on peut
aussi utiliser : menus par thèmes, complétion par tabulation, bulles d’aide pour la saisie des arguments d’une fonction 2 ou recherche par mot clef 3 .
1.2
Types et affectations
En python et dans xcas il existe de nombreux types différents. En revanche il n’y a pas de
déclaration de types ni de définition des variables. C’est au moment de l’affectation qu’une variable
obtient un type (typage dynamique). Les variables déclarées dans une fonction ont une portee
locale.
1.2.1
Types élémentaires
Les entiers, les entiers de taille arbitraire , les flottants, les booléens, les chaines de caractères.
(python)
IDLE 2 . 6 . 6
>>> a=2∗∗4 # l a v a r i a b l e a r e c o i t l a v a l e u r 24
>>> a
16
>>> 2∗∗64
# 264
18446744073709551616L
>>> 0 . 3 ∗ ∗ 6 4
3 . 4 3 3 6 8 3 8 2 0 2 9 2 5 0 4 4 e −34
>>> 5==5
# On f a i t a p p a r a i t r e l e b o o l e e n v r a i en comparant 5 e t 5
True
>>> a=” debut du t e x t e ” # on d e f i n i t une c h a i n e de c a r a c t e r e
>>> b= ’ e t l a s u i t e ’
# on a l e c h o i x pour d e l i m i t e r l a c h a i n e e n t r e ” ou ’
>>> a+b # on j u x t a p o s e l e s deux c h a i n e s a e t b
’ debut du t e x t e e t l a s u i t e ’
>>> a=”Dans une c h a i n e d e l i m i t e e par \” i l e s t i n u t i l e de p r o t e g e r l e s ’ ”
>>> a
1. identique à celle ci http://docs.python.org/release/2.7.2
2. Ex : on tape : int( puis on attend sans bouger la souris que la bulle apparaisse
3. Ex : bien que pgcd ne soit pas un nom de fonction xcas, taper ?pgcd permet de trouver la bonne instruction.
1
’ Dans une c h a i n e d e l i m i t e e par ” i l e s t i n u t i l e de p r o t e g e r l e s \ ’ ’
>>> p r i n t a
Dans une c h a i n e d e l i m i t e e par ” i l e s t i n u t i l e de p r o t e g e r l e s ’
Sous xcas, l’affectation se fait avec := alors que pour python c’est =. En revanche de nombreux
opérateurs valables en python font parties des syntaxes possibles sous xcas.
(giac/xcas)
0>> a :=2∗∗64
// Dans x c a s l ’ a f f e c t a t i o n e s t d i f f e r e n t e , c ’ e s t :=
18446744073709551616
1>> 2ˆ64
// on p e u t a u s s i u t i l i s e r 2ˆ64 pour 264
18446744073709551616
2>> 5==5;
/∗ I l n ’ y a pas de t y p e b o o l e e n , ce s o n t d e s e n t i e r s : 1 ou 0 . ∗/
1
3>> c :=” ne pas u t i l i s e r l e s ’ pour d e l i m i t e r l e s c h a i n e s dans x c a s . ” ; type ( c ) ;
DOM STRING
4>> ’ 2+2 ’ ; type ( ’ 2+2 ’ ) ; e v a l ( ’ 2+2 ’ ) // c ’ e s t r e s e r v e pour ne pas e v a l u e r une
e x p r e s s i o n . c f forme i n e r t e
2+2 ,DOM SYMBOLIC, 4
Exercice 1.2.1 En python et dans xcas, utiliser la fonction type() sur les deux entiers ci dessus. Etudier dans les deux logiciels les résultats et le type des entrées suivantes : 1/3, 1.0/3,
(1.0/3)**2000 ? Trouver (éventuellement dans l’aide) une fonction permettant de convertir un
entier en un décimal. (Ex 2 en 2.0) Dans quel cas les logiciels diffèrent ils ? Trouver dans xcas
comment faire apparaitre une valeur approchée de 1/3 avec 100 chiffres.
Python
giac ou Xcas
1.2.2
affectation puissance
reste
=
**
2/3
2.0/3
:=
ˆ ou ** irem(2,3) 2.0/3
commentaires
#
// ou /* */
Séquences : T-uples, listes, ensembles, dictionnaires
On utilisera essentiellement les listes. On retiendra juste l’existence des ensembles et dictionnaires et comment s’informer rapidement sur ces notions dans la documentation en cas de besoin.
(python)
>>> a =(11 ,22 , ” peu i m p o r t e ” , 4 4 , 1 1 ) # un t−u p l e . Ses e n t r e e s ne s o n t pas m o d i f i a b l e s .
>>> a [ 0 ]
11
>>> b = [ 1 1 , 2 2 , ” peu i m p o r t e l e type ” , 4 4 , 1 1 , r a n g e ( 3 , 8 ) ] # une l i s t e .
>>> b [ 1 ] = 2 2 2 ; b
#Les e n t r e e s d ’ une l i s t e s o n t m o d i f i a b l e s .
[ 1 1 , 2 2 2 , ’ peu i m p o r t e ’ , 4 4 , 1 1 , [ 3 , 4 , 5 , 6 , 7 ] ]
>>> b [ 0 ] , b [ 3 ] , b [ 5 ]
(11 , 44 , [ 3 , 4 , 5 , 6 , 7 ] )
>>> b [ 5 ] [ 0 ] #L ’ e l e m e n t d ’ i n d i c e 0 de l a l i s t e b [ 5 ] . En python b [ 5 , 0 ] e s t i n c o r r e c t .
3
>>> c=s e t ( a ) ; c # on p e u t c r e e r un e n s e m b l e a p a r t i r d ’ une l i s t e ou d ’ un t−u p l e
s e t ( [ ’ peu i m p o r t e ’ , 1 1 , 4 4 , 2 2 ] )
>>> c [ 0 ] # I l n ’ y a pas d ’ i n d i c e s pour l e s e n s e m b l e s en python .
Traceback ( most r e c e n t c a l l l a s t ) :
F i l e ”<s t d i n >” , l i n e 1 , i n <module>
TypeError : ’ s e t ’ o b j e c t d o e s not s u p p o r t i n d e x i n g
>>> bureau={”han” : ” 9D11” , ”hermann” : ” 9D23” , ” d a n i l a ” : ” 9D3” , 1 1 2 : ” pas de bureau ” }
>>> bureau [ ”hermann” ] #on a c r e e un d i c t i o n n a i r e . On a c c e d e aux e l e m e n t s
’ 9D23 ’
>>> bureau [ 1 1 2 ] #par d e s o b j e t s de t y p e q u e l c o n q u e e t non par d e s i n d i c e s .
’ pas de bureau ’
Dans xcas il n’y a que des listes (modifiables). On peut utiliser () ou [], c’est sur la façon de traiter
les emboitements que les choses diffèrent.
2
(giac/xcas)
9>> a : = ( 1 1 , 2 2 , ” t e x t e ” , ( 1 , 2 ) , 1 1 ) // I c i l e s n i v e a u x de ( ) ne comptent pas .
11 ,22 , ” texte ” ,1 ,2 ,11
10>> b : = [ 1 1 , 2 2 , ” t e x t e ” , [ 1 , 2 ] , 1 1 ] // Les n i v e a u x de [ ] comptent
[11 ,22 , ” texte ” ,[1 ,2] ,11]
11>> a [ 0 ] : = 1 1 1 // Dans x c a s l e s o b j e t s s o n t m o d i f i a b l e s
111 ,22 , ” texte ” ,1 ,2 ,11
12>> b [ 0 ] : = 1 1 1
[111 ,22 , ” texte ” ,[1 ,2] ,11]
13>> b [ 3 ] [ 0 ] ; // ou b i e n b [ 3 , 0 ] .
1
14>> s e t [ 1 , 3 , 2 , 2 ] // Dans xcas , l e s e n s e m b l e s s o n t a u s s i n o t e s : %{1 ,3 ,2 ,2%}
set [1 ,2 ,3]
15>> bureau := t a b l e ( ”han”=” 9D11” , ”hermann”=” 9D23” , ” d a n i l a ”=” 9D3” ,112= ” pas de bureau ” ) ;
//NB: Dans une t a b l e t o u s l e s t y p e s s o n t a c c e p t e s . Cf d i c t i o n n a i r e en python
table (
112 = ” pas de bureau ” ,
” d a n i l a ” = ” 9D3” ,
”han” = ” 9D11” ,
”hermann” = ” 9D23”
)
16>> bureau [ ”han” ] ; bureau [ 1 1 2 ] //On a c c e d e aux e l e m e n t s par d e s o b j e t s
”9D11” , ” pas de bureau ”
1.2.3
Affectations : valeur ou adresse ?
Une première difficulté. Des questions à se poser avec chaque logiciel ou language.
(python)
a =1;b=a ; b=2; print a , b
l a = [ 1 1 , 2 2 , 3 3 ] ; l b=l a ; l b [0]= −7; print l a , l b
(giac/xcas)
a : = 1 : ; b:=a : ; b : = 2 : ; //Dans x c a s pour ne pas a f f i c h e r l a r e p o n s e on u t i l i s e : ;
print ( a , b ) ; // l e ; s e r t a s e p a r e r l e s i n s t r u c t i o n s dans un programme
l a : = [ 1 1 , 2 2 , 3 3 ] : ; l b := l a : ; l b [ 0 ] : = − 7 : ;
a f f i c h e r ( l a , l b ) // l e ; e s t f a c u l t a t i f en mode i n t e r a c t i f .
Remarque 1.2.2 xcas possède une autre affectation que := appelée affectation sur place dans la
documentation. Elle se fait par le symbole =<
(giac/xcas)
l a = < [ 1 1 , 2 2 , 3 3 ] : ; l b=<l a : ; l b [0]= < −7:;
a f f i c h e r ( l a , l b ) // l e ; e s t f a c u l t a t i f en mode i n t e r a c t i f .
Exercice 1.2.3 Essayez lb[0]:=7 au lieu du =<
1.3
Instructions de contrôle
! En python il n’y a pas de délimiteurs de blocs, c’est l’indentation qui compte :
4
3
1.3.1
Tests
i f ( a <7):
print ” a
print ” a
else :
print ” a
print ” a
(python)
i n f e r i e u r a 7”
i n f e r i e u r a 7”
vaut au moins 7 ”
vaut au moins 7 ”
Xcas possède une syntaxe proche du C (Les boucles et tests coı̈ncident à part l’affectation qui est
:= sous xcas et = en C) :
(giac/xcas)
i f ( a <7){
print ( ”a<7” )
}
else {
print ( ”a>=7” )
}
On peut aussi utiliser un syntaxe de type algorithmique.
(giac/xcas)
s i ( a<7) a l o r s
a f f i c h e r ( ”a<7” )
sinon
print ( ”a>=7” )
fsi
Les instructions de comparaison en python et xcas sont les mêmes :
x
x
x
x
x
x
== y
!= y
> y
< y
>= y
<= y
1.3.2
#
#
#
#
#
#
x
x
x
x
x
x
est
est
est
est
est
est
Boucles
>>> a = 0
>>> w h i l e ( a < 7 ) :
...
a = a + 1
...
print (a)
\’egal \‘a y
diff\’erent de y. NB <> est obsolete en python.
plus grand que y
plus petit que y
plus grand que, ou \’egal \‘a y
plus petit que, ou \’egal \‘a y
(python)
# ( n ’ o u b l i e z pas l e d o u b l e p o i n t ! )
# ( n ’ o u b l i e z pas l ’ i n d e n t a t i o n ! )
(giac/xcas)
a :=0;
while ( a<7) // f a i r e s h i f t e n t r e e pour a l l e r a l a l i g n e s a n s e v a l u e r
{
a:=a +1; // ou b i e n a++ ou b i e n a+=1
print ( a ) ;
}
tantque a<17 f a i r e
a:=a +2;
print ( a ) ;
ftantque ; // en f a i t x c a s t o l e r e l ’ a b s e n c e de ; mais pas g i a c
4
En python il faut créer une liste pour pouvoir faire une boucle for.
>>>
[0 ,
>>>
[3 ,
(python)
r a n g e ( 1 0 ) # on p e u t u t i l i s e r range ou x r a n g e pour c r e e r une l i s t e
1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9]
r a n g e ( 3 , 1 0 , 2 ) # h e l p ( range ) donne l e s o p t i o n s de range
5 , 7 , 9]
On calcule donc
9
X
3i ainsi :
i=0
(python)
s=0
for i in r a n g e ( 1 0 ) :
s=s +3∗∗ i // l e c o r p s de l a b o u c l e e s t donne par l ’ i n d e n t a t i o n .
print s
4
Sous xcas la lettre i est réservée au nombre complexe.
(giac/xcas)
s :=0;
fo r ( j : = 0 ; j <10; j ++){
s := s +3ˆ j ;
}
(giac/xcas)
s :=0;
pour j de 0 jusque 9 f a i r e
s := s +3ˆ j ;
fpour
s :=0;
pour j de 0 jusque 9 pas 2 f a i r e // pour a l l e r de 2 en 2
s := s +3ˆ j ;
fpour
(giac/xcas)
(giac/xcas)
s :=0;
pour j de 0 jusque 9 f a i r e
s := s +3ˆ j ;
fpour
Exercice 1.3.1 En utilisant dans xcas la syntaxe for( ; ; ) créez une bouble de type while.
On peut aussi utiliser des listes avec xcas. L’analogue python de range est seq
(giac/xcas)
2>> s := s e q ( j ˆ 2 , j , 1 , 1 0 ) // s e q donne une s u i t e e n t r e ( )
(1 ,4 ,9 ,16 ,25 ,36 ,49 ,64 ,81 ,100)
3>> s e q ( j ˆ 2 , j = 1 . . 1 0 )
1 ,4 ,9 ,16 ,25 ,36 ,49 ,64 ,81 ,100
4>> s e q ( j ˆ 2 , j = 1 . . 1 0 , 2 ) // pour a l l e r de 2 en 2 on a j o u t e un argument
1 ,9 ,25 ,49 ,81
5>>[ s ] // pour p a s s e r d ’ une s u i t e e n t r e ( ) a une l i s t e e n t r e [ ]
4. sauf en mode maple
5
(giac/xcas)
s :=0;
L:= s e q ( t , t , 0 , 9 ) ;
fo r j i n L do // ne marche pas en f r a n c a i s
s := s +3ˆ j ;
end ;
1.4
1.4.1
Fonctions
Définition et type de variables
En python et xcas il n’y a pas de déclaration de type pour les arguments d’une fonction, ni pour
les valeurs de retour. On peut retourner n’importe quel objet ( même une liste)
(python)
def d i s c r i ( a , b , c ) :
””” C e t t e f o n c t i o n c a l c u l e l e d i s c r i m i n a n t de axˆ2+bx+c ””” # a i d e f a c u l t a t i v e
d=b∗∗2−4∗a ∗ c #En python , v a r i a b l e s l o c a l e s par d e f a u t . ( Sinon u t i s e r g l o b a l )
return d
>>> d i s c r i ( 1 , 2 , 1 )
0
>>> h e l p ( d i s c r i )
Help on f u n c t i o n d i s c r i i n module
(python)
main
:
discri (a , b , c )
C e t t e f o n c t i o n c a l c u l e l e d i s c r i m i n a n t de axˆ2+bx+c
d i s c r i ( a , b , c ):={
l o c a l d ; // par d e f a u t l e s v a r i a b l e s s o n t g l o b a l e s mais un warning s ’ a f f i c h e
d:=bˆ2−4∗a∗ c ;
return ( d ) ; // ou b i e n : d ;
le retour est la derniere evaluation
}
(giac/xcas)
(giac/xcas)
fonction d i s c r i ( a , b , c )
l o c a l d ; // par d e f a u t l e s v a r i a b l e s s o n t g l o b a l e s mais un warning s ’ a f f i c h e
d:=bˆ2−4∗a∗ c ; // ou b i e n b ∗∗2−4∗a∗ c
retourne ( d ) ; // ou b i e n : d; ou b i e n : retourne d;
ffon ction
1.4.2
Arguments des fonctions et affectations en Python
def t e s t 1 ( b ) :
b=b+1
print ( ”b dans l a f o n c t i o n ” , b )
return b
(python)
>>> a=1
>>> t e s t 1 ( a )
(python)
6
( ’ b dans l a f o n c t i o n ’ , 2 )
2
>>> p r i n t a
1
def t e s t 2 ( b ) :
b=[0]
print ( ”b dans l a f o n c t i o n ” , b )
return b
(python)
>>>
>>>
( ’b
[0]
>>>
[1]
>>>
(python)
a =[1]
test2 (a)
dans l a f o n c t i o n ’ , [ 0 ] )
print a
a=1
def t e s t 3 ( b ) :
b[0]=b[0]+1
print ( ”b dans l a f o n c t i o n ” , b )
return b
(python)
>>>
>>>
( ’b
[2]
>>>
[2]
(python)
a =[1]
test3 (a)
dans l a f o n c t i o n ’ , [ 2 ] )
print a
1.4.3
Arguments des fonctions et affectations sous Xcas
(giac/xcas)
t e s t 1 ( b ):={
b:=b+1;
print ( ”b dans l a f o n c t i o n ” , b ) ;
return b ;
};
(giac/xcas)
t e s t 2 ( b ):={
b : = [ 2 ] ; // i l y a r e c o p i e l o c a l e de b
print ( ”b dans l a f o n c t i o n ” , b ) ;
return b ;
}
(giac/xcas)
t e s t 3 ( b ):={
b [ 0 ] : = b [ 0 ] + 1 ; // i l y a t o u t de meme r e c o p i e l o c a l e de b
print ( ”b dans l a f o n c t i o n ” , b ) ;
return b ;
}
7
En utilisant l’affectation sur place =< on obtient le même comportement qu’en Python. (ie que les
listes sont des pointeurs, mais que l’argument d’une fonction est recopié localement et donc non
modifié.)
(giac/xcas)
t e s t 4 ( b ):={
b = <[2]; // a f f e c t a t i o n s u r p l a c e
print ( ”b dans l a f o n c t i o n ” , b ) ;
return b ;
}
(giac/xcas)
t e s t 5 ( b ):={
b[0]= <b [ 0 ] + 1 ; // a f f e c t a t i o n s u r p l a c e
print ( ”b dans l a f o n c t i o n ” , b ) ;
return b ;
}
(giac/xcas)
4>> ( a : = 1 ) , t e s t 1 ( a ) , a ;
”b dans l a f o n c t i o n ” , 2
1 ,2 ,1
5>> ( a : = [ 1 ] ) , t e s t 2 ( a ) , a ;
”b dans l a f o n c t i o n ” , [ 1 ]
[1] ,[2] ,[1]
6>> ( a : = [ 1 ] ) , t e s t 3 ( a ) , a ;
”b dans l a f o n c t i o n ” , [ 2 ]
[1] ,[2] ,[1]
7>> ( a : = [ 1 ] ) , t e s t 4 ( a ) , a ;
”b dans l a f o n c t i o n ” , [ 2 ]
[ 1 ] , [ 2 ] , [ 1 ] // a n ’ e s t pas m o d i f i e c a r c ’ e t a i t l ’ argument .
8>> ( a : = [ 1 ] ) ; t e s t 5 ( a ) ; a ;
”b dans l a f o n c t i o n ” , [ 2 ]
[ 2 ] , [ 2 ] , [ 2 ] // l ’ a f f i c h a g e a l i e u a p r e s e v a l u a t i o n de t o u t e l a l i g n e ce q u i
e x p l i q u e l e p r e m i e r 2 . Le contenu de l a l i s t e a e s t m o d i f i e c a r on a m o d i f i e
une e n t r e e de l a l i s t e a l o r s que l ’ argument de l a f o n c t i o n e t a i t l a l i s t e .
8