- memento - mpsi/pcsi - cahier-de-prepa.fr

26 août 2021

- Memento -

MPSI/PCSI

Table des matières1 Commandes de base 3

1.1 Assigner/afficher/demander/aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Opérations/fonctions usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Types Python 42.1 Les types les plus courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Zoom sur les types itérables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2.1 Listes/tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2.2 Générer des listes/tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2.3 Slicing sur les itérables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.4 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4 Matrices, opérations principales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Algorithmique 83.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.2 Test if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.3 Fonctions def . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.4 Boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Compléments 124.1 Tracés 2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124.2 Autres tracés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134.3 Manipulation de fichiers/répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1/15 (c) Lycée Cézanne, Aix-en-Provence

Index

append , 5

bool , 4chdir , 14close , 14complex , 4copy , 5count , 5, 7def , 10dir , 3dot , 2, 8float , 4for , 8function , 4getcwd , 14

global , 10

help , 3

input , 3len , 5linalg , 7

linspace , 12

listdir , 14

np. dot , 8

np. shape , 8

np.identity , 8np.zeros , 8ones , 6open , 14os , 14plt.plot , 12pop , 5

print , 3range , 6readlines , 14readline , 14replace , 7

reshape , 6return , 10reverse , 5savefig , 14set , 4shape , 2, 5, 8

split , 7str , 4sum , 5tuple , 4type , 3

while , 11write , 14zeros , 6

Bouclefor , 8while , 11

Chaînes de caractères, 7Compréhension (génération par), 6Conversion, 4

Dictionnaires, 7

FonctionsPython, 10

in place, 3itérables, 4

Lambda (fonction), 4Listes, 5

matplotlib, 12Matrices, 7

Opérationsmatrices, 7usuelles, 3

Slicing, 6

Tableaux, 5Test if , 9

2

1 Commandes de base

1.1 Assigner/afficher/demander/aide

Action Entrée Sortie

Assignation x=1 La variable x prendla valeur 1

Assignation multiple a,b=0,1 Pareil que a=0 et b=1Incrémenter x+=y Change x en x+y in placeDécrémenter x-=y Change x en x-y in place

Convertir x=truc(y) Si possible, convertit y en le type truc ( int,str ,etc.)Afficher

(sortie écran) print ("salut") Affichage de salut à l’écran (et c’est tout)

Poser une question age= input ("Quel âge as tu ?")

(question entre "" optionnelle)

Stocke la réponse dans la variable age"qui sera de type str

pour la convertir en entier age=int(age)

Demander le type type (objet) type Python

Catalogue objet dir (objet) Liste fonctions/méthodes relatives

Aide en ligne help (commande) Aide

Commentaires # Passe le reste de la ligneen mode commentaire

• Remarque : ça veut dire quoi in place ? Chaque variable pointe vers une case mémoire qui recèle soncontenu. Par exemple, si l’on tape x=4 , Python crée une case mémoire contenant la valeur 4 , vers laquelle la variable x pointera.

➣une modification in place du type x+=1 change directement la valeur dans la case mémoire verslaquelle pointe x (en l’occurence en 5 ) ;

➣la commande x=x+1 semble analogue, mais en fait fonctionne en deux étapes :

crée une nouvelle case mémoire contenant la valeur x+1 ; repointe la variable x vers cette nouvelle case : plus gourmand en mémoire, on préfèrera donc systé-matiquement les modifications in place.

1.2 Opérations/fonctions usuelles

Action Python Exemple

Addition + 2+3 → 5Multiplication ∗ 2 ∗ 3 → 6Puissance ∗∗ 2 ∗∗ 3 → 8

Division décimaux / 5/2 → 2.5 en Python 3

Quotient DE // 7/3 → 2 en 2.7

Reste DE % 7 % 3 → 1Addition dans Rn

array +np.array([1,2])+np.array([2,3])

→ np.array([3,5])Addition/concaténationsur les list ou str

+ [1,2]+[3,4] → [1,2,3,4]

Multiplication/concaténationlist ou str

∗ [1,2]*3 → [1,2,1,2,1,2]

Fonction usuelle Nom usuel

pas classique : np.sqrt(2) (racine)

np.floor(4.5) (partie entière)

abs(-3) (valeur absolue)

3/15 (c) Lycée Cézanne 2021/2022

2 Types Python

2.1 Les types les plus courants

• Remarque : pour les fonctions, on pourra en voir plus en section ?? page ??.

Maths Ex. maths Type Ex. Python Itérable ?

Booléen Vrai ou Faux bool True/False Non

Entier 12 int 12 NonDécimal 1,2 float 1.2 NonComplexe 1 + 2i complex 1+2j Non

Fonction f : x 7→ e−x function f = lambda x : exp(-x) Non

Liste [1,2,3] list l=[1,2,3] l[1] → 2

Liste (de listes) [[1,2],[3,4]] list l=[[1,2],[3,4]]

{

l[0] → [1,2]l[1][0] → 3

Ensemble s = {1, 2, 3} set s={1,2,3} s[2] → 3

p-uplet t=(1,2,3) tuple t=(1,2,3) t[0] → 1Chaîne

caractères Texte normal str mot="Salut" mot[1] → "a"

Tableaux T =

[ [1 2 3

]

[4 5 6

]

]

np.array T=np.array([[1,2,3],[4,5,6]])

{

T[1,2] → 6T[0 :2,1] → [2,5]

Conversion Voir remarque

• Remarque :❶ ( Conversion d’un objet en un autre type) a nouveau=nouveautype(ancien) . Exemples :

➣conversion ensemble → liste : a=list({1,2,3}) → a= [1,2,3] ;

➣conversion décimal → chaine de caractères : mot=str(12) → mot="12" .

❷ liste des objets vides : [ ] liste vide, { } ensemble vide, "" chaine vide.

2.2 Zoom sur les types itérables

• Les listes ( list ), tableaux ( array ), et chaînes de caractères ( str ) sont des itérables :

❶ on peut accéder au i-ème élément d’un iterable avec iterable[i] , "à la numérotation qui part

de 0. Voici l’indexation de la chaîne mot=’Monty Python’ avec des zones de slicing :

"comme le montre le dessin ci-dessus, l’indexation commence à 0 et pas 1 donc si iterable=’Monty Python’ ,

iterable[1] renverra ’o’ c’est parfois très piégeux...

a. À l’exception de la conversion list → tableau multi-dimensionnel, voir la commande np.reshape en section 2.2.2.


❷ on peut les parcourir avec des boucles (les itérer), deux syntaxes possibles :

### Option 1for e lement in i t e r a b l e :

#−>[t ap e r l e s i n s t r u c t i o n s r e l a t i v e s Ã e lement ]### Option 2for i in range (len ( i t e r a b l e ) ) : #l e n=l ongu eu r

#−>[t ap e r l e s i n s t r u c t i o n s r e l a t i v e s Ã i e t /ou i t e r a b l e [ i ]

Voici chacune de ces syntaxes destinées à afficher chaque lettre d’une chaîne de caractère mot :

### Option 1

for l e t t r e in mot :print ( l e t t r e )

### Option 2

for i in range (len (mot ) ) :print (mot [ i ] )

• Remarque : la première a l’air plus simple, mais la seconde permet de manipuler les élémentsmot[i] en même temps que leur emplacement i .

2.2.1 Listes/tableaux


Accéder à un élément liste[0],liste[i],liste[-1] Premier, i-ème,dernier élément

Longueur d’une liste len ( [1,2,3] ) 3

Rajouter à une liste a. append (4) Rajoute 4 à la fin in place de a

Concaténer listes [1,2,3]+[4] [1,2,3,4]

Répéter liste [1,2] ∗ 3 [1,2,1,2,1,2]

Expulser un élément a. pop () Expulse le dernier élément de a in place

Trier a.sort() Trie a par ordre croissant in place

Symétrie centrale a. reverse () Inverse les éléments d’une liste in place

Tester l’appartenance 1 in [1,2,3] ou 5 in [1,2,3] True ou False

Sommer sur une liste sum ( [1,2,-2]) 1

Format tableau tableau. shape donne nbre de lignes, de colonnes

Extraire (sclicing) 1-d Si a=[0,1,2,3,4,5] a[0 :3] → [0,1,2]

Extraire tableau 2d Si a=np.array( [ [1,2,3] , [4,5,6] ] ) a[0 :2,1 :3] → np.array([[2, 3], [5, 6]])

Compter apparitions Si a=[1,1,2,3] a. count (1) → 2

Créer une copie de a b=np. copy (a) Crée une copie b indépendante de a

2.2.2 Générer des listes/tableaux

• Remarque : on s’assurera de bien maîtriser la génération par compréhension (filtrée ou pas) exposéedans le tableau qui suit, terriblement pratique pour créer des listes sans passer par une boucle.



Générer liste d’entiers [[a; b[[ range (6) ou range(1,4) [0,1,3,4,5] ou [1,2,3]"pas le dernier

Générer subdivision de [0, 10]à 3 pts np.linspace(0,10,3) np.array([ 0., 5., 10.])

Générer subdivision de [0, 10]avec un pas de 2 np.arange(0,10,2) np.array([0, 2, 4, 6, 8])

Génération par compréhension [i**2 for i in range(5)] [0,1,4,9,16]Génération filtréeici filtre = être pair [i**2 for i in range(5) if i%2 == 0] [0, 4, 16]

Multiplication/concaténation [0]*3 ou [ [1,2]*2 ] [0,0,0] ou [[1,2],[1,2]]

Générer tableau de zéros np. zeros ((2,3)) np.array([ [0,0,0],[0,0,0] ])

Générer tableau de uns np. ones ((2,3)) np.array([ [1,1,1],[1,1,1] ])

Changer format tableau np. reshape (np.array([1,2,3,4]),(2,2)) np.array([[1, 2], [3, 4]])

2.2.3 Slicing sur les itérables

• Le slicing (découpage) est un moyen très rapide pour extraire un itérable d’un autre.

➣Exemple sur un tableau 6x1 : si L=[a,b,c,d,e,f] , L[2 :5] sera la liste [c,d,e] .

Le schéma ci-dessus illustre d’autres slicing possibles.

➣Exemple sur un tableau 6x6 : ça marche pareil...


2.2.4 Chaînes de caractères


Accéder à une lettre mot[0],mot[i],mot[-1] Cf. listes

Longueur d’une chaîne len("python") 6Concaténer chaînes "pyt"+"hon" "python"Aller à la ligne " Salut \ n ça va ?" Va à la ligne à l’affichage

Répéter chaîne "Ok" ∗ 3 "OkOkOk"Tester l’inclusion "py" in "python" ou "pi" in "python" True ou FalseRemplacer dans "python". replace ("py","zz") "zzthon"Découper selon si mot="a b c" alors mot. split (" ") → liste ["a","b","c"]

Compter apparition si a="coco" a. count ("o") → 2

2.3 Dictionnaires

• La structure de dictionnaire permet d’associer des clés à des valeurs, par exemple :dict= { 1 : "Premier" , 2 : "Deuxième", "Troisième" : 3 }

Ici les clés sont 1,2,"Troisième" et "Premier" est la valeur associée à la clé 1 .


Afficher valeur dict[1] "Premier"

Lister les items dict.items() [(1, ’Premier’), (2, ’Deuxième’), (’Troisième’, 3)]

Lister les clés dict.keys() [1, 2, ’Troisième’]

Lister les valeurs dict.values() [’Premier’, ’Deuxième’, 3]

Ajouter dict[4]="Quatrième" None

Supprimer une entrée par clé del dict[2] None

Vérifier la présence d’une clé dict.has_key("Troisième") True

2.4 Matrices, opérations principales

• Les matrices peuvent être vus comme des tableaux 2-d, par exemple M =

(1 23 4

)

peut se déclarer en

Python :

➣comme un tableau 2-d : M= np.array( [ [1,2] ,[3,4] ] ) ;

➣ou plus simplement comme une liste de listes : M= [ [1,2] ,[3,4] ] , mais"la commande d’addition

+ n’aura pas l’effet attendu (sur des listes, ça concatène !).

• Avec la matrice M =

(1 23 4

)

déclarée par M=np.array([[1,2],[3,4]]) , "le module linalg se charge

par from scipy import linalg :



Format np. shape (M) Tuple lignes/colonnes ici ( 2, 2 )

Coeff. ligne 0 colonne 1 M[0][1] ou M[0,1] 2

Ligne 0 M[0] [1,2]

Colonne 1 M[ :,1] np.array([2,4]) (le : décrit l’itérable)

Addition M+M "seulement si M est déclaré en np.arrayLoi externe 0.5*M "seulement si M est déclaré en np.arrayInverse linalg.inv(M) np.array([[ 0.5, 0.5], [-0.5, 0.5]])

Transposée M.T np.array([[1,3],[2,4]])

"Produit matriciel np. dot (A,B) Produit A×B

Déterminant, trace linalg.det(M),linalg.tr(M) 5,-2

Génerer matrice nulle N= np.zeros ( (2,3) ) N devient(0 0 00 0 0

)

Matrice identité np.identity (3) I3

Générer matrice diagonale np.diag(liste)Matrice diagonale à

coeff. formés par listeReformater N=np.reshape(M,(1,4)) N=np.array([1,2,3,4])

Puissance np.linalg.matrix_power(M,3) Puissance 3ème

Résolution MX = Y np.linalg.solve(M,Y) Donne Y en ligne pour X entré en ligne

Valeurs propres np.linalg.eigvals(M) Ligne des VP (avec répétition)

VP + Vecteur propres np.linalg.eig(M)Ligne des VP,

matrice des−−→V P en ligne, unitaires

associés dans l’ordre aux VP

3 Algorithmique

3.1 Boucles for

• Principe général :

for compteur in i t e r a b l e :#l e s deux p o i n t s c r e e n t une i n d e n t a t i o n#−>[t ap e r l e s i n s t r u c t i o n s a e x é c u t e r pour chaque va l e u r de l ’ i t e r a b l e ]

# r e v e n i r s u r l ’ i n d e n t a t i o n marque l a f i n de l a bouc l e

❶ Typiquement, l’itérable est un range(a,b) ("c’est l’intervalle d’entiers [[a ; b − 1]]) ou une liste ;

❷ Pour parcourir les indices d’une liste, on écrit for compteur in range(len(liste)) : ou alors

for element in liste : .

• Exemple :❶ vous trouverez en section 2.2 page 4 les deux rédactions pour parcourir les itérables avec une boucle.❷ pour afficher a2 pour a dans [[0 ; 4]]..

>>> for a in range (5 ) :print( a ∗∗2)

014916


Ici, le compteur est a qui décrit l’itérable est la liste range(5)=[0,1,2,3,4] de type liste .

❸ Compter a le nombre de "o" dans "bonjour" :

>>> mot , v a l e u r=’ bon jou r ’ ,0>>> for l e t t r e in mot :

if l e t t r e==’ o ’ :v a l e u r+=1

>>> va l e u r2

3.2 Test if

• Principe général :

1 if c o n d i t i o n 1 :2 #in d e n t a t i o n3 #−>[t ap e r l e s i n s t r u c t i o n s a e f f e c t u e r s i l a c o n d i t i o n 1 e s t ok ]4 elif c o n d i t i o n 2 : # op t i o nn e l , s e r a examine s i l a c o n d i t i o n 1 n ’ e s t pas ok5 #−>[t ap e r l e s i n s t r u c t i o n s a e f f e c t u e r s i l a c o n d i t i o n 2 e s t ok ]6 else : # op t i o nn e l , s i r i e n n ’ a marche7 #−>[t ap e r l e s i n s t r u c t i o n s a e f f e c t u e r s i r i e n n ’ a marche ]

Typiquement, les conditions sont des booléens (càd une assertion vraie= True ou fausse= False ) définispar une condition de type :

➣ a ==b (test d’égalité b) entre deux éléments de même type ;

➣ a !=b (test de différence) entre deux éléments de même type ;

➣ a in b (test d’appartenance) pour savoir si a est un élément c de b ;

➣ a <=b ou a >=b pour comparer deux éléments qui peuvent l’être ;

➣des liaisons and (et), or (ou), not (négation) entre une ou plusieurs des propositions précédentes.

• Exemple :❶ un test de divisibilité par 3 :

1 x=322 if x%3==0: # r a p p e l % e s t l e r e s t e de l a d i v i s i o n3 print ( " d i v i s i b l e par 3 ! " )

qui n’affiche rien à la compilation

❷ un test prévoyant plus de possibilités :

1 x=322 if x%3==0: # r a p p e l % e s t l e r e s t e de l a d i v i s i o n3 print ( " d i v i s i b l e par 3 ! " )4 elif x%2=0:5 print ( " d i v i s i b l e par 2 ! " )6 else :7 print ( " d i v i s i b l e n i par 2 , n i par 3 ! " )

qui affichera "divisible par 2 !" à la compilation.

a. Peut se faire directement avec la méthode count .b. L’égalité dans un test se rédige par DEUX symboles « = », pas naturel au début et source de beaucoup de plantages...c. Pour les str , teste si a est une sous-chaine de b , par exemple "bon" in "bonjour" est True .


3.3 Fonctions def

• Principe général.

def f o n c t i o n ( en t r e e1 , en t r e e1 , . . . ) : # i l peut y a v o i r une s e u l e entrÃ©e ou aucune#l e s deux p o i n t s c r e e n t une i n d e n t a t i o n#−>[ i n s t r u c t i o n s a e x e c u t e r ]# ATTENTION : l a p rocedu re s ’ a r r e t e au p r em i e r r e t u r nreturn ( s o r t i e )

Schématiquement, la fonction est la flèche dans le schéma suivant :

Entrées

résultat

Effectue les instructions

dans l’indentationreturn résultat

• Remarque :

❶ "le programme sort de la fonction dès qu’il tombe sur un return , ce qui peut donner des sur-

prises s’ils sont mal placés dans les indentations ;

❷ les variables autres que celles de l’entrée déclarées dans la procédure sont des variables dites locales :utilisées de manière interne à la procédure, effacées à la sortie (on parle de portée locale). Si l’onveut conserver l’état d’une variable x (n’existant pas ailleurs dans le programme) après la sortieon la déclare comme globale dans la procédure par un global x situé juste après la premièreindentation.

• Exemple :

❶ Fonction f définie par :

➣Entrée : une variable x ;

➣Sortie : la valeur x+1 .

def f ( x ) : #I c i l ’ e n t r e e s e resume a une v a r i a b l e xreturn ( x+1) #I c i l a s o r t i e s e resume a une v a r i a b l e ( con tenan t x+1)

• Remarque :

➣l’appel f(4) retournera 5 ;

➣x 7→ x+ 1 peut aussi être définie par la lambda-fonction f = lambda x : x+1

❷ Fonction compte définie par :

➣Entrée : un tuple mot,lettre avec mot une chaîne de caractère, lettre une chaîne réduite àun élément ;

➣Sortie : le nombre de fois que la lettre apparaît dans le mot .

10/15 (c) Lycée Cézanne 2021/2022

def compte (mot , l e t t r e ) : # i c i deux e n t r e e sr e s u l t a t=0for i n d i c e in range (len (mot ) ) : #pour p a r c o u r i r t ou s l e s i n d i c e s

if mot [ i n d i c e ]== l e t t r e :r e s u l t a t+=1

return r e s u l t a t

• Exemple : l’appel compte(’marseille’,’e’) renverra l’entier 2.

❸ Fonction test définie par :

➣Entrée : une tuple L,n avec L une liste et n un entier ;

➣Sortie : un booléen True si n est un élément de la liste, False sinon.

1 def t e s t (L , n ) :2 for i in range(len ( L ) ) : # au t r e op t i o n " f o r e lement i n L : "3 if L [ i ]==n : # au t r e op t i o n " i f e l ement==n ; "4 return True5 return Fa l s e

• Remarque :

➣par exemple, l’appel test([1,2,2,1],3) renverra False .

➣le retour peut intervenir dans un test, par exemple if test(L,n)==True : ;

➣placer un return dans l’indentation du if ligne 3 permet une sortie de boucle/fonction dès quele résultat est positif, ce qui permet de ne pas tout parcourir dans ce cas et gagne du temps.

3.4 Boucles while

• Principe général : dans ce qui suit, bool est un booléen càd pouvant être seulement True ouFalse , par exemple c’est un test a>0 .

while bool :#l e s deux p o i n t s c r e e n t une i n d e n t a t i o n#−>[ i n s t r u c t i o n s a e x e c u t e r t a n t que boo l e s t True ]#ATTENTION s ’ a s s u r e r que boo l s e r a Fa l s e au bout d ’ un moment . . .#. . . s i n on bouc l e i n f i n i e e t p l a n t a g e .

"il faut s’assurer que la condition bool sera False au bout d’un moment, au risque d’avoir une boucleinfinie faisant planter l’ordi (voir principe de Terminaison section ??).

• Exemple : pour une suite définie par u0 = 0, on définit un+1 = u2n+ 1 et on veut déterminer le plus

petit indice n tel que un > 50.

va l e u r , i n d i c e =0,0while va l e u r <50: #tan t que [NEGATION DE CE QUE L ’ON VEUT]

i n d i c e+=1v a l e u r=va l e u r ∗∗2+1print ( ’ Rang ’+str ( i n d i c e )+’ , s u i t e= ’+str ( v a l e u r ) )

# ce qu i s u i t s e r a e x e cu t e en s o r t i e de bouc l e vu l ’ i n d e n t a t i o n :print ( ’ Le p r em i e r rang ou l on depas s e 50 e s t ’+str ( i n d i c e −1) )# c e l a donne :Rang 1 , s u i t e= 1Rang 2 , s u i t e= 2

11/15 (c) Lycée Cézanne 2021/2022

Rang 3 , s u i t e= 5Rang 4 , s u i t e= 26Rang 5 , s u i t e= 677Le p r em i e r i n d i c e ou l on depas s e 50 e s t 4

C’est la variable valeur qui prend les valeurs successives de la suite, à ne pas confondre avec la variableindice qui joue ici le rôle de n.

4 Compléments

4.1 Tracés 2d

• Recommandé d’importer le package en entier, sans préfixe par :

import matplotlib.pyplot as plt

• Principe général d’un tracé :

plt.plot (

liste abscisses︷︸︸︷

[x1, . . . , xn] ,

liste ordonnées︷︸︸︷

[y1, . . . , yn] )

trace la ligne brisée joignant les points M1(x1, y1), . . . , Mn(xn, yn)

• Remarque :❶ typiquement (voir exemple ci-dessous) la liste des abscisses est générée comme dans la section 2.2.2

page 5, avec un linspace et celle des ordonnées est une λ-fonction de la première ;

❷ "sur certaines installations, les graphiques ne s’affichent qu’à la commande plt.show() ;

❸ "dans les syntaxes qui suivent, la partie options est facultative. Les options se piochent parmile tableau qui suit celui ci-dessous :

Commandes Syntaxe

Générer une légende axe des x (ou y) plt.xlabel("texte")

Générer une grille plt.grid()

Générer une ligne brisée de sommetsd’abscisse/ordonnées connues

plt.plot(list_abscisses,list_ordonnées,options)voir plus bas pour les options de tracé

Générer un tracé de y = f(x) sur x dans [a, b]discrétisé à 20 points

x=np.linspace(a,b,20)plt.plot(x,f(x),options)

Courbe paramétrée (x(t), y(t)) pour t dans [a, b]discrétisé à 20 points

t=np.linspace(a,b,20)plt.plot(x(t),y(t),options)

Réglages axes plt.xlim(xmin, xmax) plt.ylim(ymin, ymax)

Afficher les tracés plt.show()

Histogramme d’une liste liste plt.hist(liste)

Vider les tracés générés plt.clf() (clear figure)

• Options de tracé :

12/15 (c) Lycée Cézanne 2021/2022

Options syntaxe

Epaisseur ligne linewidth="4" pour 4 pixelsStyle tiret ou pointillés linestyle="dashed" ou "dotted"

Couleur color="blue"

Associer une légende label="Texte" (faire legend(loc=0)avant pour un bon emplacement

Désactiver lignes linestyle="none"

Activer marqueurs aux sommets marker="o",markersize=choixautres marqueurs ∗, x

• Un petit exemple :

import numpy as npfrom ma t p l o t l i b . p yp l o t import ∗f = lambda x : np . s i n ( x ) # d e c l a r a t i o n f o n c t i o n##### BEL EMPLACEMENT DE LEGENDESlegend ( l o c =0)##### LEGENDES SUR LES AXESx l a b e l ( "x" )y l a b e l ( "y" )##### GENERATION D’UN TRIANGLE A(0 , 0 ) ,B( p i , 0 ) ,C( p i /2 ,1)absc =[0 , np . p i , np . p i /2 ,0 ]ordo =[0 ,0 ,1 ,0 ]t r i a n g l e=p l o t ( absc , ordo , l i n e s t y l e="dashed " , marker="o" , l a b e l=" T r i a n g l e " )##### GENRATION y=f ( x )a b s c i s s e s=np . l i n s p a c e (0 ,2∗ p i , 5 0 ) # d i s c r e t i s a t i o n Ã 50 p t so rdonnee s=f ( a b s c i s s e s ) #g e n e r a t i o n o rdonnee sg raphe_s inus=p l o t ( a b s c i s s e s , ordonnees , l i n ew i d t h="3" , l a b e l=" s i n u s " )l egend ( )##### ET MAINTENANT ON AFFICHEshow ( )

donne :

4.2 Autres tracésOn peut copier/coller/adapter des codes à partir de la page :https://matplotlib.org/2.0.2/gallery.html

13/15 (c) Lycée Cézanne 2021/2022

https://matplotlib.org/2.0.2/gallery.html

4.3 Manipulation de fichiers/répertoires

• Gestion du répertoire courant avec le module import os .

• Remarque : dans les fichiers, le symbole \n désigne un retour à la ligne.


Refermer/sauvegarder truc.close() Comme dit

Gérer répertoire courant import os Charge le module adéquat

Liste fichiers ds répertoire courant os. listdir () Comme dit

Afficher répertoire courant os. getcwd () Comme dit

Changer répertoire courant os. chdir ("C :\skynet\Document\") Déplace le répertoire courantà l’adresse indiquée

"il y a parfois un bug sur la donnée des chemins ; par exemple "C :\Users\Documents\" peut poser

problème. L’explication est que le groupe \U est une commande reconnue et automatiquement executéepar l’éditeur/encodeur (qui bugge car elle est hors-propos). Le bug se résout en rajoutant un « r » audébut du chemin, en l’ocurrence en changeant en :r"C :\Users\Documents\"


Charger en mode lecture fichier= open ("chemin","r") Stockage dans fichieren mode "Read"

Charger fichier enmode écriture ("efface contenu)

truc=open("fichier","w") Stockage dans fichieren mode "Write"

Lire la prochaine ligne fichier. readline ()"Salut !\n"

(un \n est un retour à la ligne)Charger fichier en

mode append =écriture possibleou création si n’∃ pas

truc=open("fichier","a") Stockage dans fichieren mode "Write"

Lire la prochaine ligne fichier. readline ()"Salut !\n"

(un \n est un retour à la ligne)

Génère la listede toutes les lignes

fichier.readlines()["Salut !\n","Ca va ?"]

(un \n est un retour à la ligne)

Stocker ligne ligne=fichier. readlines ()[0] Sauvegarde 1ère ligne

Séparer ligne en mots ligne.split(" ") Sépare selon espaces(ou autre)

Écrire dans fichier fichier. write ("Youpi !") Rajoute "Youpi !" dans truc"penser à refermer

Sauver fichier fichier. close () Sauvegardele répertoire courant

Sauver figure savefig ("nom_fichier")Sauvegarde la figure dans

le répertoire courant(format .png )

• Exemple : récupération des phrases dans un fichier, création de la liste des premiers mots.

14/15 (c) Lycée Cézanne 2021/2022

import os # pe rmet tan t de g e r e r l e r e p e r t o i r e . Les commandes r e l a t i v e s

os . c h d i r ( r ’C: \ Use r s \ Skynet I I \Documents \Cours 2014−2015\ I n f o ’ )

f i c h i e r=open ( ’ t e x t e . t x t ’ , ’ r ’ ) # ouv e r t u r e mode l e c t u r el i g n e s=f i c h i e r . r e a d l i n e s ( ) #Cr e a t i o n de l a l i s t e des l i g n e s

p r emie r smot s =[ ]for l i g n e in l i g n e s :

l i g n e=l i g n e . s p l i t ( " " ) # s é p a r a t i o n de l a ph ra se en mots , on coupe auxe s pa c e s

p r emie r smot s . append ( l i g n e [ 0 ] )

15/15 (c) Lycée Cézanne 2021/2022